Promptez votre base de données SQL !

En combinant les capacités de l’IA et des bases de données SQL, vous pouvez optimiser l’utilisation des ressources informatiques et humaines. Les utilisateurs peuvent obtenir des informations pertinentes plus rapidement et plus facilement, améliorant ainsi leur expérience globale. Enfin, l’intégration de l’IA permet d’explorer de nouvelles façons d’utiliser les données pour innover et rester compétitif.

Pourquoi établir une communication DB -> IA ?

Mettre en place une connexion entre une application, une base de données et un modèle d’IA présente plusieurs avantages :

Automatisation et Efficacité

  • Automatisation des tâches répétitives : L’IA peut automatiser des requêtes complexes et des analyses de données, réduisant ainsi le temps et les efforts nécessaires pour obtenir des informations pertinentes.
  • Réponses rapides et précises : En utilisant l’IA pour interroger la base de données, vous pouvez obtenir des réponses rapides et précises à des questions spécifiques sans avoir à écrire des requêtes SQL complexes.

Amélioration de la Prise de Décision

  • Analyses avancées : L’IA peut analyser de grandes quantités de données et identifier des tendances ou des anomalies que les humains pourraient manquer.
  • Prédictions et recommandations : Les modèles d’IA peuvent fournir des prédictions basées sur les données historiques et offrir des recommandations pour des actions futures.

Accessibilité et Utilisabilité

  • Interface utilisateur simplifiée : Les utilisateurs peuvent interagir avec la base de données via des prompts en langage naturel, rendant l’accès aux données plus intuitif et accessible même pour ceux qui ne maîtrisent pas le langage de base de données.
  • Support multilingue : Azure OpenAI peut comprendre et répondre dans plusieurs langues, ce qui est utile pour les entreprises internationales.

Sécurité et Conformité

  • Contrôle d’accès : Vous pouvez définir des niveaux d’accès pour différents utilisateurs, garantissant que seules les personnes autorisées peuvent interroger certaines parties de la base de données.
  • Surveillance et audit : Les interactions avec la base de données peuvent être surveillées et auditées pour assurer la conformité avec les régulations et les politiques internes.

Flexibilité et Évolutivité

  • Scalabilité : Azure offre des solutions évolutives qui peuvent gérer des volumes de données croissants sans compromettre les performances.
  • Intégration facile : Les services Azure sont conçus pour s’intégrer facilement avec d’autres outils et plateformes, facilitant ainsi l’expansion et l’adaptation aux besoins changeants de l’entreprise.

Mais comment y parvenir ?

Bien que la mise en place de cette interface puisse sembler complexe, elle est tout à fait réalisable avec une planification adéquate et les bonnes compétences.

Si vous avez une équipe technique compétente ou si vous pouvez faire appel à des experts, cela facilitera grandement le processus.

Configuration de la Base de Données

  • Création et gestion de la base de données : Assurez-vous que votre base de données est bien structurée et optimisée pour les requêtes que vous souhaitez exécuter.
  • Sécurité et accès : Configurez les permissions et les accès pour garantir la sécurité des données.

Intégration de l’Application

  • Développement de l’application : Utilisez un langage de programmation compatible (comme Python, C#, etc.) pour développer l’application qui interagira avec la base de données et l’IA.
  • API et connecteurs : Utilisez des API et des connecteurs pour permettre à l’application de communiquer avec la base de données SQL et les services Azure.

Configuration du Modèle d’IA

  • Choix du modèle : Sélectionnez le modèle d’IA approprié sur Azure OpenAI en fonction de vos besoins (par exemple, GPT-4).
  • Entraînement et ajustement : Si nécessaire, entraînez le modèle avec des données spécifiques à votre domaine pour améliorer sa précision.

Développement de l’Interface Utilisateur

  • Interface utilisateur : Créez une interface utilisateur intuitive qui permet aux utilisateurs de saisir des prompts en langage naturel.
  • Traitement des requêtes : Développez des mécanismes pour convertir les prompts en requêtes SQL et pour afficher les résultats de manière compréhensible.

Considérations Techniques

  • Compétences requises : Vous aurez besoin de compétences en développement logiciel, en gestion de bases de données et en IA.
  • Ressources : Assurez-vous d’avoir les ressources nécessaires, y compris le temps, le budget et l’infrastructure.
  • Maintenance : Préparez-vous à effectuer une maintenance régulière pour assurer la sécurité et la performance de l’application.

Outils et Services Utiles disponibles sur Azure

  • Azure SQL Database : Pour la gestion de la base de données.
  • Azure OpenAI Service : Pour l’intégration du modèle d’IA.

Maintenant, il nous reste plus qu’à tester tout cela 😎💪

Etape 0 – Rappel des prérequis :

Afin de tester la mise en place d’une application entre Azure OpenIA et une base de données Azure SQL, nous allons avoir besoin de :

Etape I – Préparation du poste local :

Installez Visual Studio Code ou un éditeur de code similaire :

Téléchargez puis installez la version 6.0 de .NET, disponible via ce lien officiel :

Téléchargez et installez SQL Server Management Studio (SSMS) depuis cette page :

Afin de publier les 2 applications sur une URL publique, téléchargez ngrok, puis inscrivez-vous chez eux avec un compte gratuit :

Sur leur site, téléchargez l’installateur de ngrok :

Copiez la commande suivante affichée sous l’installateur pour configurer votre ngrok :

Depuis le dossier de téléchargement, ouvrez une invite de commande, puis lancez celle-ci afin de préparer votre configuration ngrok :

Le poste local est maintenant correctement configuré, la prochaine étape consiste à créer une base de données SQL avec de la données fictives sur notre souscription Azure.

Etape II – Création de la base de données Azure SQL :

Pour cela, rendez-vous sur la page du portail Azure afin de rechercher le service Azure SQL Database :

Cliquez-ici pour créer votre base de données SQL :

Nommez votre base de données Azure SQL, puis cliquez-ici pour créer une serveur de base de données Azure pour héberger notre base :

Nommez votre serveur Azure SQL, choisissez sa région, puis renseignez des identifiants SQL pour simplifier notre test :

Conservez votre environnement en Développement, réduisez la redondance de votre base de données SQL, puis cliquez sur Suivant :

Conservez les caractéristiques réseaux d’origine, puis cliquez sur Suivant :

Conservez les caractéristiques de sécurités d’origine, puis cliquez sur Suivant :

Ne configurez pas de source de données particulière, puis lancez la validation Azure :

Une fois la validation Azure réussie, lancez la création des ressources Azure :

Attendez environ 5 minutes, puis cliquez-ici pour accéder à votre base de données Azure SQL :

Copiez les informations de connexion à votre base de données SQL, celles-ci seront nécessaire par la suite :

Retournez sur la page principale de votre base de données SQL, puis cliquez sur votre serveur Azure SQL :

Dans la section réseau, activez l’option suivante, puis rajoutez votre adresse IP publique en exception Firewall afin de pouvoir connecter votre poste à la base de données SQL, puis cliquez sur Sauvegarder :

Rendez-vous sur la page GitHub suivante afin de récupérer le script de chargement d’une base de données SQL (Northwind) en exemple, puis cliquez-ici :

Téléchargez le script de chargement en cliquant sur le bouton suivant :

Une fois le script téléchargé, ouvrez SQL Server Management Studio sur votre poste :

Renseignez les informations reprises sur votre serveur Azure SQL créé précédemment, puis cliquez sur Connecter :

Cliquez-ici pour rechercher votre script SQL téléchargé précédemment :

Choisissez le script SQL, puis cliquez sur Ouvrir :

Une fois le script affiché dans une nouvelle fenêtre, cliquez sur Exécuter pour démarrer ce dernier :

Attendez environ 30 secondes que celui-ci se termine avec le message suivant :

Contrôlez dans la base de données Azure SQL créés en premier que les différentes tables sont présentes et que des données y sont stockées :

Nos données sont maintenant stockées dans notre base Azure SQL. Nous pouvoir maintenant mettre en place notre LLM grâce au service Azure OpenAI.

Etape III – Création du modèle Azure OpenAI :

Pour cela, retournez sur la page du portail Azure afin de rechercher le service Azure OpenAI :

Cliquez-ici pour créer votre service Azure Open AI ;

Renseignez les informations de base de ce dernier, puis cliquez sur Suivant :

Conservez les caractéristiques réseaux d’origine, puis cliquez sur Suivant :

Ajoutez au besoin des étiquettes, puis cliquez sur Suivant :

Une fois la validation Azure réussie, lancez la création des ressources Azure :

Attendez environ 1 minutes puis cliquez-ici pour accéder à votre service Azure OpenAI :

Copiez les 2 informations suivantes pour ouvrir un accès auprès de votre service Azure OpenAI :

Cliquez-ici pour ouvrir le portail Azure OpenAI Studio :

Cliquez-ici pour déployer un nouveau model :

Choisissez le type gpt-4, puis cliquez sur Confirmer :

Nommez votre déploiement, définissez une limite de tokens par minute qui convient, puis cliquez sur Déployer :

Attendez environ 1 minute le temps de déploiement de votre modèle :

L’infrastructure sur Azure est maintenant en place. Il nous nous reste qu’à configurer les applications web sur notre poste afin que celle-ci travaille avec le schéma de votre base de données et votre modèle AI.

Commençons par la version 1 proposée par Alex Wolf.

Etape IV – Configuration de l’application v1 :

Voici un lien vers son excellente vidéo présentant l’application v1, sa configuration, son code ainsi qu’une comparaison intéressante faite avec les services Search basés sur l’IA :

Rendez-vous sur un fork de la page GitHub d’Alex Wolf afin de télécharger l’application v1 sous format ZIP :

Un fois l’archive ZIP téléchargée, décompressez celle-ci dans le dossier local de votre choix :

Ouvrez votre éditeur de code local, puis cliquez-ici pour ouvrir le dossier de l’application v1 :

Ouvrez le dossier correspondant au dossier suivant :

Dans le dossier SchemaLoader\SchemaLoader ouvrez le fichier Program.cs, puis renseignez la connexion à votre base de données Azure SQL copiée précédemment :

N’oubliez pas de de modifier le mot de passe de votre compte SQL, puis sauvegardez :

Ouvrez une première fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :

dotnet build ".\SchemaLoader.csproj" -c Debug -o .\bin\Debug\net6.

Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :

dotnet run

Une fois l’application démarrée, copiez le texte généré par celle-ci et contenant le schéma de votre base de données Azure SQL :

Retournez sur votre éditeur de code, puis allez dans le dossier dbchatui, ouvrez le fichier DataService.cs, renseignez à nouveau la connexion à votre base de données Azure SQL, puis sauvegardez le fichier :

Allez dans le dossier dbchatui\Pages, ouvrez le fichier Index.cshtml.cs, copiez le schéma de votre base de données Azure SQL :

Cela donne la présentation suivante :

Toujours dans le fichier Index.cshtml.cs, renseignez les 3 informations suivantes pour connecter votre application à votre modèle Azure OpenAI, puis sauvegardez :

Rouvrez la fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :

dotnet build ".\YourOwnData.csproj" -c Debug -o .\bin\Debug\net6.

Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :

dotnet run

Votre application v1 est maintenant démarrée. Copiez le numéro du port local ouvert pour cette application :

Ouvrez une seconde fenêtre Windows Terminal, puis saisissez la commande suivante afin d’exposer votre application locale au travers de ngrok :

Copiez l’URL publique générée par ngrok ci-dessous :

Tout l’environnement de test est maintenant en place, il nous reste qu’à tester le fonctionnement de l’application v1. Ouvrez un navigateur web, collez l’URL ngrok précédemment copiée, puis confirmez la navigation en cliquant ici :

Commencez par tester une requête SQL simple en promptant une question basique :

L’application vous retourne d’abord sa compréhension de votre demande, et la transpose en une requête SQL correspondante :

Juste en dessous est affiché les enregistrement correspondants au résultat de la requête exécutée sur votre serveur de base de données Azure SQL :

Continuez en testant des prompts incluant des filtres, des classements, … :

Continuez en testant des prompts incluant des relations de tables et des filtres basés sur un raisonnement :

Tous ces prompts nous montrent l’immense potentiel de pouvoir prompter une IA qui a une connaissance du schéma de toute la base de données source, sans pour autant avoir la données en elles-mêmes.

Etape V – Configuration de l’application v2 :

Il existe une nouvelle application toujours développée par Alex Wolf dont la vidéo est juste là :

Le principe est le même, rendez-vous sur un fork de la page GitHub d’Alex Wolf afin de télécharger l’application v2 sous format ZIP :

Un fois l’archive ZIP téléchargée, décompressez celle-ci dans le dossier local de votre choix :

Ouvrez votre éditeur de code local, cliquez-ici pour ouvrir le dossier de l’application v2, renseignez les 3 informations suivantes pour connecter votre application à votre modèle Azure OpenAI, puis sauvegardez :

Ouvrez une première fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :

dotnet build ".\DBChatPro.csproj" -c Debug -o .\bin\Debug\net6.

Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :

dotnet run

Votre application v2 est maintenant démarrée. Copiez le numéro du port local ouvert pour cette application :

Ouvrez une seconde fenêtre Windows Terminal, puis saisissez la commande suivante afin d’exposer votre application locale au travers de ngrok :

Copiez l’URL publique générée par ngrok ci-dessous :

Tout l’environnement de test est maintenant en place, il nous reste qu’à tester le fonctionnement de l’application v1. Ouvrez un navigateur web, collez l’URL ngrok précédemment copiée, puis confirmez la navigation en cliquant ici :

Renseignez la connexion à votre base de données Azure SQL copiée précédemment, puis cliquez-ici pour le schéma :

Cliquez sur Sauvegarder :

La connexion apparaît alors dans la liste des connexions existantes :

Retournez sur le premier onglet, puis commencez par tester une requête SQL simple en promptant une question basique :

L’application v2 vous retourne les enregistrement correspondants au résultat de la requête exécutée sur votre serveur de base de données Azure SQL :

Le second onglet affiche une requête SQL correspondante :

Le troisième onglet vous retourne la compréhension de votre demande comprise par le modèle IA :

Un historique des précédentes prompts est également disponible :

Il également possible de mettre des prompts en favoris :

Conclusion

En conclusion, l’utilisation de prompts pour interagir avec les bases de données représente une avancée importante, simplifiant l’accès aux informations et permettant une utilisation plus intuitive de SQL.

En expérimentant avec cette méthode, les utilisateurs peuvent améliorer leur efficacité et mieux exploiter leurs données.

Avec l’évolution rapide de ces technologies, maîtriser le langage des prompts pourrait devenir une compétence clé pour les professionnels de la donnée, ouvrant la voie à de nouvelles façons de gérer et analyser des volumes d’informations toujours croissants.

Importez dans Copilot via un connecteur 🔌

J’ai reçu un mail il y a quelques jours de la part de Microsoft (oui oui, seulement un 🤣) m’invitant tester par moi-même un premier connecteur Copilot pour Microsoft 365, en suivant simplement un pas à pas technique. N’ayant pas d’expérience en .NET, je me suis dit … pourquoi pas ! Je vous propose de le réaliser ensemble pour que vous puissiez vous-même reproduire cet exercice sur votre tenant Copilot.

Dans cet article, nous reprendrons brièvement quelques concepts et nous testerons nous-même de créer un connecteur Microsoft Graph personnalisé afin d’enrichir les résultats Copilot dans Microsoft 365.

Voici encore un rappel des articles écrits autour des solutions Copilot de Microsoft :

Qu’est-ce qu’un connecteur Microsoft Graph ?

Les connecteurs Microsoft Graph vous permettent d’ingérer vos données métier non structurées dans Microsoft Graph, afin que Copilot pour Microsoft 365 puissent raisonner sur l’intégralité du contenu de votre entreprise. Le contenu ingéré via les connecteurs Graph est ajouté à Microsoft Graph ; cela déverrouille la compréhension sémantique des invites de vos utilisateurs dans Copilot pour Microsoft 365.

Microsoft Learn

Quel est l’impact d’un connecteur dans Copilot pour 365 ?

L’impact de connecteur dans les résultats Copilot peut changer la donne dans les résultats de recherche documentaire car il va fouiner en dehors de Microsoft 365.

Voici un exemple montrant des résultats avec des références externes à Microsoft 365, améliorant donc l’expérience de recherche de l’utilisateur Copilot :

Voici également une courte vidéo montrant un peu plus à ce sujet :

Peut-on gérer les droits d’accès aux données remontées via un connecteur ?

Oui, ce qui est stocké en dehors de Microsoft 365 reste accessible selon une configuration ACL de votre choix. Les documents pourraient alors être visibles par :

  • Tous les membres de votre organisation
  • Un ou des groupes 365
  • Un ou des utilisateurs 365

Important : Les autorisations d’accès au contenu externe sont directement stockées dans le système externe.

Existe-t-il des connecteurs déjà disponibles sur étagères ?

Oui, Microsoft propose déjà un site web référençant des connecteurs de plusieurs grands éditeurs :

Quelles sont les sources de données possibles via un Connecteur ?

Microsoft a déjà créé plusieurs connecteurs dont voici certains exemples de source de données :

Azure Data Lake Storage Gen2, Azure DevOps Work Items, Azure DevOps Wiki, Azure SQL and Microsoft SQL Server, Confluence Cloud, Confluence On-premises, CSV, Custom connector, Enterprise websites, Jira Cloud, MediaWiki, File share, Oracle SQL, Salesforce, ServiceNow Knowledge, ServiceNow Catalog, ServiceNow Tickets

Peut-on créer un connecteur personnalisé ?

La réponse est encore oui. Dans l’objectif de vous aider à tester Copilot avec un connecteur Microsoft Graph personnalisé, Microsoft a mis à disposition la documentation suivante.

Grâce à celle-ci, vous pouvez facilement tester intégration du contenu externe à Copilot for Microsoft 365 à l’aide de connecteurs Microsoft Graph construits avec .NET.

Dans cet exercice Microsoft, les tâches que nous allons réaliser seront donc les suivantes :

Commençons par un bref rappel des prérequis.

Etape 0 – Rappel des prérequis :

Pour réaliser cet exercice sur un connecteur Microsoft Graph, il vous faudra disposer des éléments suivants :

  • Un tenant Microsoft
  • Une licence Copilot pour Microsoft 365
  • Une des licences 365 suivantes :
    • Microsoft 365 E5
    • Microsoft 365 E3
    • Office 365 E3
    • Office 365 E5
    • Microsoft 365 A5
    • Microsoft 365 A3
    • Office 365 A5
    • Office 365 A3
    • Microsoft 365 Business Standard
    • Microsoft 365 Business Premium

Avant de créer le connecteur Microsoft Graph personnalisé, faisons un premier de test de prompt à Copilot pour évaluer les réponses obtenues.

Etape I – Premier test Copilot sans connecteur :

Pour cela, ouvrez votre navigateur internet sur la page web de Copilot en mode Work :

Saisissez le prompt suivant :

please find a doc how to install a Microsoft Graph SDK

Copilot vous informe qu’il ne trouve aucun document stocké dans les données d’entreprise, ou qu’aucun document ne vous est accessible.

Notez que le Plugin Web n’est pas activé, ce qui aurait pu donner un résultat également différent :

Nous allons maintenant mettre en place un connecteur Microsoft Graph personnalisé afin d’en mesurer le changement des réponses de Copilot.

Etape II – Préparation du poste local :

Pour plus de facilité, commencez par télécharger Visual Studio Code via la page officielle de téléchargement :

Une fois l’installeur téléchargé, exécutez celui-ci

Acceptez les conditions d’utilisation, puis cliquez sur Suivant :

Définissez le répertoire d’installation, puis cliquez sur Suivant :

Cliquez sur Suivant :

Cliquez sur Suivant :

Cliquez sur Installer :

Attendez 1 minute que l’installation de Visual Studio Code se termine :

Cliquez sur Terminer :

Une fois dans Visual Studio Code, allez dans le menu Extensions, puis installez l’extension simplement nommée C# :

Retournez sur votre navigateur internet afin de télécharger la version 8.0.1 du SDK .NET :

Une fois l’installation téléchargée, exécutez celle-ci :

Cliquez sur Installer :

Confirmez l’action de sécurité Windows en cliquant sur Oui :

Attendez 1 minute que l’installation de .NET se termine :

Cliquez sur Fermer :

Redémarrer votre poste Windows afin de prendre en compte la nouvelle version .NET :

Notre poste est maintenant prêt pour la création d’un connecteur Microsoft Graph personnalisé.

Nous allons commencer par la préparation de notre tenant à gérer les authentification de notre connecteur à Microsoft 365 à l’API de Microsoft Graph.

Etape III – Création d’une Inscription d’application Entra :

Rendez-vous sur la page du portail Azure disponible juste ici, puis ouvrez le service Microsoft Entra ID :

Dans le menu Inscriptions d’applications, cliquez-ici pour créer une nouvelle Inscription :

Nommez votre application, puis cliquez sur Inscrire :

Attendez quelques secondes la notification suivante :

Cliquez sur le menu Certificats et secrets, puis ajoutez un nouveau secret client comme ceci :

Nommez-le, puis cliquez sur Ajouter :

Copiez la valeur de votre secret. Ce dernier sera utilisé par votre connecteur Microsoft Graph afin qu’il s’authentifie automatiquement :

Dans le menu des Permissions API, cliquez-ici pour ajouter des permissions supplémentaires :

Choisissez l’API Microsoft Graph :

Cliquez sur Permissions d’application :

Recherchez et cochez les 2 permissions suivantes en utilisant la barre de recherche, puis cliquez sur Ajouter les permissions :

  • ExternalConnection 
    • ExternalConnection.ReadWrite.OwnedBy
  • ExternalItem 
    • ExternalItem.ReadWrite.OwnedBy

Enfin, cliquez sur le bouton suivant afin d’appliquer ces permissions au niveau du tenant :

Confirmez votre choix en cliquant sur Oui :

Leur statut s’en retrouve alors changé comme ceci :

La configuration du côté du tenant est en partie terminée. Nous allons maintenant nous intéresser l’écriture du code en .NET de notre connecteur Microsoft Graph.

Etape IV – Création du connecteur Microsoft Graph personnalisé :

Dans l’explorateur Windows, créez un dossier pour y stocker le codes et les données de votre futur connecteur Microsoft Graph :

Retournez dans Visual Studio Code, puis cliquez ici pour vous positionnez sur ce nouveau répertoire :

Cliquez sur Oui :

Dans la console située en bas de votre écran, vérifiez le bon positionnement de votre dossier, puis lancez la commande suivante pour créer une nouvelle console dédiée à votre application .NET :

dotnet new console

Notez l’apparition de fichiers suivants dans l’explorateur Windows :

Ajoutez la bibliothèque suivante pour s’authentifier auprès des services Microsoft 365 :

dotnet add package Azure.Identity

Ajoutez la bibliothèque cliente suivante pour communiquer à l’API Microsoft Graph :

dotnet add package Microsoft.Graph

Ajoutez la bibliothèque suivante pour gérer les secrets :

dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Ajoutez la bibliothèque suivante pour intégrer des commandes dans l’application :

dotnet add package System.CommandLine --prerelease

Afin de stocker les secrets de notre application, lancez la commande suivante :

dotnet user-secrets init

Conservez les 3 informations de votre Inscription d’application pour vous authentifier automatiquement auprès de Microsoft 365 :

  • ID de l’application
  • Valeur du secret
  • ID du tenant

Saisissez les commandes suivantes pour les stocker de manière sécurisée en remplaçant les 3 valeurs en gras par celles récupérées juste avant :

dotnet user-secrets set "EntraId:ClientId" "[application id]"
dotnet user-secrets set "EntraId:ClientSecret" "[secret value]"
dotnet user-secrets set "EntraId:TenantId" "[tenant id]"

Continuons la configuration par la connexion entre le connecteur personnalisé et l’API Microsoft API.

Etape V – Configuration de la connexion avec l’API Microsoft Graph :

Le premier fichier va être utile à gérer les informations de la connexion entre le connecteur personnalisé et l’API Microsoft Graph.

Dans Visual Studio Code, créez un premier fichier texte en cliquant juste ici :

Choisissez le type de fichier texte :

Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom GraphService.cs :

using Azure.Identity;
using Microsoft.Graph;
using Microsoft.Extensions.Configuration;

class GraphService
{
  static GraphServiceClient? _client;

  public static GraphServiceClient Client
  {
    get
    {
      if (_client is null)
      {
        var builder = new ConfigurationBuilder().   AddUserSecrets<GraphService>();
        var config = builder.Build();

        var clientId = config["EntraId:ClientId"];
        var clientSecret = config["EntraId:ClientSecret"];
        var tenantId = config["EntraId:TenantId"];

        var credential = new ClientSecretCredential(tenantId, clientId,    clientSecret);
        _client = new GraphServiceClient(credential);
      }

      return _client;
    }
  }
}

Le second fichier contient la connexion externe elle-même avec Microsoft 365 et les schémas de données envoyées à Microsoft 365.

Créer à nouveau un fichier texte, collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ConnectionConfiguration.cs :

using Microsoft.Graph.Models.ExternalConnectors;
static class ConnectionConfiguration
{
  public static ExternalConnection ExternalConnection
  {
    get
    {
      return new ExternalConnection
      {
        Id = "msgraphdocs",
        Name = "Microsoft Graph documentation",
        Description = "Documentation for Microsoft Graph API which    explains what Microsoft Graph is and how to use it."
      };
    }
  }
  public static Schema Schema
  {
    get
    {
      return new Schema
      {
        BaseType = "microsoft.graph.externalItem",
        Properties = new()
        {
          new Property
          {
            Name = "title",
            Type = PropertyType.String,
            IsQueryable = true,
            IsSearchable = true,
            IsRetrievable = true,
            Labels = new() { Label.Title }
          },
          new Property
          {
            Name = "description",
            Type = PropertyType.String,
            IsQueryable = true,
            IsSearchable = true,
            IsRetrievable = true
          },
          new Property
          {
            Name = "iconUrl",
            Type = PropertyType.String,
            IsRetrievable = true,
            Labels = new() { Label.IconUrl }
          },
          new Property
          {
            Name = "url",
            Type = PropertyType.String,
            IsRetrievable = true,
            Labels = new() { Label.Url }
          }
        }
      };
    }
  }
}

Créer un troisième fichier texte contant les demandes d’établissement de connexion entre le connecteur personnalisé et l’API de Microsoft Graph.

Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ConnectionService.cs :

using Microsoft.Graph.Models.ExternalConnectors;

static class ConnectionService
{
  async static Task CreateConnection()
  {
    Console.Write("Creating connection...");

    await GraphService.Client.External.Connections
      .PostAsync(ConnectionConfiguration.ExternalConnection);

    Console.WriteLine("DONE");
  }

  async static Task CreateSchema()
  {
    Console.WriteLine("Creating schema...");

    await GraphService.Client.External
      .Connections[ConnectionConfiguration.ExternalConnection.Id]
      .Schema
      .PatchAsync(ConnectionConfiguration.Schema);

    do
    {
      var externalConnection = await GraphService.Client.External
        .Connections[ConnectionConfiguration.ExternalConnection.Id]
        .GetAsync();

      Console.Write($"State: {externalConnection?.State.ToString()}");

      if (externalConnection?.State != ConnectionState.Draft)
      {
        Console.WriteLine();
        break;
      }

      Console.WriteLine($". Waiting 60s...");

      await Task.Delay(60_000);
    }
    while (true);

    Console.WriteLine("DONE");
  }

  public static async Task ProvisionConnection()
  {
    try
    {
      await CreateConnection();
      await CreateSchema();
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
    }
  }
}

Enfin, ouvrez le fichier Program.cs créé automatiquement dans votre dossier afin de signaler à notre l’application .NET de créer la connexion et son schéma.

Pour ce faire, remplacez le code de départ par celui-ci, puis sauvegardez-le via la commande clavier Ctrl Shift+S :

using System.CommandLine;

var provisionConnectionCommand = new Command("provision-connection",    "Provisions external connection");
provisionConnectionCommand.SetHandler(ConnectionService.   ProvisionConnection);

var rootCommand = new RootCommand();
rootCommand.AddCommand(provisionConnectionCommand);
Environment.Exit(await rootCommand.InvokeAsync(args));

Un premier test de création de connexion vers Microsoft 365 via l’API Microsoft Graph depuis notre connecteur personnalisé est déjà possible.

Etape VI – Test de connection :

Pour cela, utilisez la commande .NET suivante pour construire votre projet :

dotnet build

Démarrez l’application en exécutant la commande suivante, puis attendez :

dotnet run -- provision-connection

Ouvrez la page Search & intelligence suivante dédiée aux connecteurs de sources de données :

Continuez d’attendre la construction complète de la connexion :

Retournez sur cette même page afin de constater le changement du status de la connexion :

Nous venons de créer une connexion externe afin d’indexer nos futurs documents à venir dans Microsoft 365.

La prochaine étape consiste justement à importer de la donnée afin d’alimenter les index de Microsoft 365.

Etape VII – Configuration de l’import de contenu externe :

Un connecteur Microsoft Graph se connecte à un système externe, exporte son contenu et l’importe dans Microsoft 365. Au cours de ce processus, un connecteur graphique transforme le contenu exporté en éléments externes mettant en correspondance le contenu avec le schéma configuré sur la connexion externe.

Le contenu définit l’essentiel de l’élément qui est indexé pour la recherche en texte intégral. Pour un document ou une page wiki, il s’agit du corps du document. Pour un produit, il peut s’agir de sa description. Les connecteurs graphiques vous permettent d’importer du contenu au format texte ou HTML. Si vous importez du contenu binaire, comme des vidéos ou des images, vous devez obtenir leur représentation textuelle avant de les importer dans Microsoft 365.

Microsoft Learn

Afin de simuler facilement du contenu, Microsoft met à disposition sur GitHub des fichiers de contenu pour notre connecteur Microsoft Graph personnalisé.

Téléchargez ce contenu via ce lien GitHub, puis débloquez la protection sur l’archive ZIP :

Décompressez le contenu de l’archive dans l’arborescence de votre projet comme ceci :

Depuis l’explorateur Windows, vérifiez que le contenu de votre projet se présente sous cette forme :

Vérifiez la présence de cette nouvelle arborescence dans Visual Studio Code :

Dans Visual Studio Code, ouvrez le seul fichier .csproj présent dans votre projet :

Ajoutez le code suivant dans le fichier .csproj avant la balise </Project> pour copier le contenu, puis sauvegardez-le via la commande clavier Ctrl Shift+S :

<ItemGroup>
  <ContentFiles Include="content\**"    CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>

<Target Name="CopyContentFolder" AfterTargets="Build">
  <Copy SourceFiles="@(ContentFiles)" DestinationFiles="@   (ContentFiles->'$(OutputPath)\content\%(RecursiveDir)%(Filename)%   (Extension)')" />
</Target>

Afin d’importer les fichiers de contenu au format Markdown vers Microsoft 365, nous devons extraire les métadonnées et convertir les contenus au format texte :

Pour y arriver, nous avons besoin d’autres bibliothèques :

dotnet add package Markdig
dotnet add package YamlDotNet

Créez un quatrième fichier texte consacré à la gestion du contenu à importer. Celui-ci va réaliser les actions suivantes :

  • Configuration du traitement du format markdown
  • Extraction des contenus markdown et YAML
  • Transformation du contenu en éléments externes
  • Chargement des éléments externes dans Microsoft 365

Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ContentService.cs :

using YamlDotNet.Serialization;
using Microsoft.Graph.Models.ExternalConnectors;
using Markdig;
public interface IMarkdown
{
  string? Markdown { get; set; }
}

class DocsArticle : IMarkdown
{
  [YamlMember(Alias = "title")]
  public string? Title { get; set; }
  [YamlMember(Alias = "description")]
  public string? Description { get; set; }
  public string? Markdown { get; set; }
  public string? Content { get; set; }
  public string? RelativePath { get; set; }
}

static class ContentService
{
static IEnumerable<DocsArticle> Extract()
{
  var docs = new List<DocsArticle>();

  var contentFolder = "content";
  var contentFolderPath = Path.Combine(Directory.GetCurrentDirectory(),    contentFolder);
  var files = Directory.GetFiles(contentFolder, "*.md", SearchOption.   AllDirectories);

  foreach (var file in files)
  {
    try
    {
      var contents = File.ReadAllText(file);
      var doc = contents.GetContents<DocsArticle>();
      doc.Content = Markdown.ToHtml(doc.Markdown ?? "");
      doc.RelativePath = Path.GetRelativePath(contentFolderPath, file);
      docs.Add(doc);
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
    }
  }

  return docs;
}

  static IEnumerable<ExternalItem> Transform(IEnumerable<DocsArticle> content)
{
  var baseUrl = new Uri("https://learn.microsoft.com/graph/");

  return content.Select(a =>
  {
    var docId = GetDocId(a.RelativePath ?? "");
    return new ExternalItem
    {
      Id = docId,
      Properties = new()
      {
        AdditionalData = new Dictionary<string, object> {
            { "title", a.Title ?? "" },
            { "description", a.Description ?? "" },
            { "url", new Uri(baseUrl, a.RelativePath!.Replace(".md",    "")).ToString() }
        }
      },
      Content = new()
      {
        Value = a.Content ?? "",
        Type = ExternalItemContentType.Html
      },
      Acl = new()
      {
          new()
          {
            Type = AclType.Everyone,
            Value = "everyone",
            AccessType = AccessType.Grant
          }
      }
    };
  });
}

static async Task Load(IEnumerable<ExternalItem> items)
{
  foreach (var item in items)
  {
    Console.Write(string.Format("Loading item {0}...", item.Id));

    try
    {
      await GraphService.Client.External
        .Connections[Uri.EscapeDataString(ConnectionConfiguration.   ExternalConnection.Id!)]
        .Items[item.Id]
        .PutAsync(item);

      Console.WriteLine("DONE");
    }
    catch (Exception ex)
    {
      Console.WriteLine("ERROR");
      Console.WriteLine(ex.Message);
    }
  }
}

  public static async Task LoadContent()
  {
    var content = Extract();
    var transformed = Transform(content);
    await Load(transformed);
  }

  static string GetDocId(string relativePath)
{
  var id = relativePath.Replace(Path.DirectorySeparatorChar.ToString(),    "__").Replace(".md", "");
  return id;
}
}

Créez un cinquième fichier texte consacré à l’extraction de contenu fichiers de contenu.

Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom MarkdownExtensions.cs :

// from: https://khalidabuhakmeh.com/parse-markdown-front-matter-with-csharp
using Markdig;
using Markdig.Extensions.Yaml;
using Markdig.Syntax;
using YamlDotNet.Serialization;

public static class MarkdownExtensions
{
  private static readonly IDeserializer YamlDeserializer =
      new DeserializerBuilder()
      .IgnoreUnmatchedProperties()
      .Build();

  private static readonly MarkdownPipeline Pipeline
      = new MarkdownPipelineBuilder()
      .UseYamlFrontMatter()
      .Build();
      public static T GetContents<T>(this string markdown) where T :    IMarkdown, new()
{
  var document = Markdown.Parse(markdown, Pipeline);
  var block = document
      .Descendants<YamlFrontMatterBlock>()
      .FirstOrDefault();

  if (block == null)
    return new T { Markdown = markdown };

  var yaml =
      block
      // this is not a mistake
      // we have to call .Lines 2x
      .Lines // StringLineGroup[]
      .Lines // StringLine[]
      .OrderByDescending(x => x.Line)
      .Select(x => $"{x}\n")
      .ToList()
      .Select(x => x.Replace("---", string.Empty))
      .Where(x => !string.IsNullOrWhiteSpace(x))
      .Aggregate((s, agg) => agg + s);

  var t = YamlDeserializer.Deserialize<T>(yaml);
  t.Markdown = markdown.Substring(block.Span.End + 1);
  return t;
}
}

Enfin, rouvrez à nouveau le fichier Program.cs modifié précédemment pour y ajouter la commande de chargement du contenu, puis sauvegardez-le via la commande clavier Ctrl Shift+S :

var loadContentCommand = new Command("load-content", "Loads content   into the external connection");
loadContentCommand.SetHandler(ContentService.LoadContent);
rootCommand.AddCommand(loadContentCommand);

Etape VIII – Test d’importation :

Pour cela, utilisez la commande .NET suivante pour reconstruire à nouveau votre projet :

dotnet build

Commencez à charger le contenu vers Microsoft 365 en exécutant la commande suivante :

dotnet run -- load-content

Retournez sur la page Search & intelligence afin de constater l’ajout d’objets indexés en haut à droite :

Notre environnement 365 contient maintenant l’accès à ces nouveaux documents. Il nous faut maintenant activer cette source dans 365 pour que Copilot puisse les ressortir en résultat.

Etape IX – Activation de la connexion externe dans Copilot :

Toujours sur cette même page d’administration 365, rendez-vous sur l’onglet Personnalisations, puis cliquez-ici pour activer votre connecteur dans les résultats :

Cochez les cases suivantes pour activer votre connecteur dans les résultats Copilot :

Etape X – Second test Copilot avec connecteur :

Sur votre utilisateur ayant la licence Copilot pour Microsoft 365, retournez sur la page de Copilot en mode Work en ayant toujours aucun plugin d’actif :

Saisissez à nouveau le prompt suivant :

please find a doc how to install a Microsoft Graph SDK

Constatez l’apparition d’un résultat avec une ou plusieurs références de type Externe :

Refaite la même opération en promptant sur le même sujet, puis cliquez sur la source externe :

Constatez l’ouverture d’un nouvel onglet pointant vers la documentation Microsoft Learn car le document dispose d’une URL pointant vers celle-ci :

Conclusion

Par les extensions, Microsoft nous montre que l’IA n’en est qu’à ses débuts dans les différents systèmes de données. Les entreprises ont tout y gagner à connecter une IA sur un ensemble de plusieurs systèmes d’informations.

Savoir que je peux interroger mes stocks de marchandises, et les modifier au besoin dans mes autres systèmes au moyen d’une IA connectée me fait espérer beaucoup d’innovations pour les années à venir :

Je souhaite donc continuer à écrire d’autres articles sur l’IA. Par exemple, en testant les Quickstarts proposés par Microsoft, comme Build your first custom Microsoft Graph connector.

Votre Copilot a faim ! 🍔

Copilot pour Microsoft 365 fait maintenant partie de votre quotidien depuis plusieurs semaines ? Vous êtes donc un utilisateur régulier de Copilot dans plusieurs applications 365 ? En ressentez-vous déjà les premiers impacts sur votre productivité ?

Copilot pourrait-il en faire plus ?

Il est possible que vous soyez prêts à élargir le périmètre de votre Copilot ! Pour cela, prenez le temps de savoir comment Copilot pourrait exploiter d’autres données, et surtout comment il s’y prendrait.

Voici déjà quelques articles écrits sur ce blog autour des solutions Copilot de Microsoft :

Comme le rappelle Microsoft, Copilot est en soit l’IA générative actuellement la plus adaptée aux applications et données présentes dans Microsoft 365 :

En soi, Copilot pour Microsoft 365 est un outil de productivité puissant pour maintenir les utilisateurs dans le flux de leur travail dans les applications Microsoft 365. Il fournit aux utilisateurs des compétences générales telles que la compréhension, la synthèse, la prédiction, le rappel, la traduction et la génération de contenu.

Il s’appuie sur une base de référence de vos connaissances organisationnelles en indexant du contenu dans Microsoft Graph, tel que les e-mails, les conversations et les documents auxquels les utilisateurs ont l’autorisation d’accéder.

Microsoft Learn

Copilot pour Microsoft 365 a été annoncé il y a longtemps, mais les choses évoluant très rapidement, prenez-le temps de regarder cette vidéo en français pour comprendre un peu mieux Copilot pour Microsoft 365 :

Je pense que ce schéma a déjà dû passer sous vos yeux à plusieurs reprises, mais il est facile à comprendre car il montre les avantages natifs d’un Copilot déjà connecté aux données de votre tenant.

De ce fait, et sans rien faire d’autres qu’acheter des licences Copilot pour Microsoft 365, le schéma technique de votre IA Copilot ressemble déjà à ça :

Alors, pourquoi en faire plus ?

Car l’IT d’une entreprise a de nombreuses vies et ne se limite pas aux outils 365 et aux données stockées dans SharePoint, OneDrive et autres.

Bien souvent, d’autres outils proviennent d’éditeurs tiers ou sont créés en internes pour des besoins métiers. La donnée peut donc se trouver en dehors de l’environnement 365 et possiblement sous des formats spécifiques.

Techniquement, Copilot pour Microsoft 365 ne peut donc pas s’inspirer de cette donnée inconnue ou même la proposer si un utilisateur lui en fait la demande via un prompt.

Mais une fois en place, votre Copilot pour Microsoft 365 dispose de plusieurs possibilités pour étendre son périmètre pour coller toujours plus aux besoins :

Pour vous faire une meilleure idée, voici un exemple assez parlant donné par Microsoft :

  • Suivi des problèmes pour l’équipe d’ingénierie : Supposons que votre équipe d’ingénierie s’appuie sur un logiciel de gestion de projet. Vous pouvez créer un outil personnalisé qui permet aux utilisateurs de surveiller les tickets ouverts. Un utilisateur peut demander des informations sur tous les problèmes qui lui sont attribués, et Copilot pour Microsoft 365 peut récupérer et présenter ces données en toute transparence à partir de votre plugin.

Imaginez alors d’autres données relatives aux ressources humaines, à la comptabilité, aux outils de productions industrielles ou encore à la finance ? Tout cela à la portée d’un simple prompt à Copilot ?

Oui mais, comment s’y prend-on ?

Rien n’est automatique, mais Microsoft vous propose déjà 2 approches pour y parvenir :

  • Plugin : Ideal pour les données structurées. Développez des plugins qui utilisent le schéma OpenAI pour ajouter des fonctionnalités personnalisées aux expériences Microsoft Copilot, en connectant les données de votre propre application à Microsoft Copilot. Les plugins permettent à une expérience Copilot d’interagir avec vos propres API, améliorant ainsi l’expérience pour effectuer un plus grand nombre d’actions. (Source : Microsoft)
  • Connecteur : Ideal pour les données non structurées. Le connecteur vous permet d’ingérer vos données métier non structurées dans Microsoft Graph, afin que Copilot pour Microsoft 365 puissent raisonner sur l’intégralité du contenu de votre entreprise. Le contenu ingéré via les connecteurs Graph est ajouté à Microsoft Graph ; cela déverrouille la compréhension sémantique des invites de vos utilisateurs dans Copilot pour Microsoft 365. (Source : Microsoft)

Mais alors, lequel choisir ?

Pour vous aider au mieux à comprendre, cette vidéo de Microsoft vous montre justement les impacts en situation réelle :

Pour vous aider à faire votre choix, Microsoft a également mis à disposition cet arbre de décision :

Attention, la structure de la donnée pourrait avoir elle aussi un impact sur votre choix :

ConnecteursPlugins
StructureDonnées non structurées ou aplatisDonnées structurées
Volume de donnéesJusqu’à 5 millions d’éléments par connexionConvient pour les données à volume élevé (plus de 5 M)
Activité des donnéesJusqu’à 20 demandes par secondeAdapté à une activité élevée (plus de 20 req/s.)
Lecture/ÉcritureLecture seuleInscriptible

Enfin, Microsoft liste ici les avantages techniques des 2 solutions :

ConnecteursPlugins
AvantagesPertinence basée sur les activités de l’utilisateur. Détection sémantique du contenu sans activation d’un plugin. Activités (telles que l’affichage, la modification et le partage) avec aide sur le classement et la pertinence des résultats de recherche. Les données restent dans les limites de conformitéDétectabilité dans le Windows Store. Activation de l’expérience de marque. Meilleure expérience utilisateur avec les cartes adaptatives
Fonctionnalités de l’expérience développeurConnexion rapide, schéma d’inscription et éléments d’indexKit de ressources Teams pour Visual Studio & VS Code. Chargement de version test pour le développement & test
Fonctionnez également avecIQ de contexte, Viva Topics, Recherche d’entreprise dans M365.com, SharePoint et Bing @ work. Recommandations de contenu dans les applications M365Conversation Teams, Outlook

Existe-t-il des limitations techniques ?

En effet, les 2 options présentent des limitations techniques qui peuvent influer sur votre choix :

ConnecteursPlugins
Limites30 connecteurs maximum dans le locataire.

Volume de données et activité relativement faibles.

Visibilité de l’application pour les utilisateurs.
Maximum d’un million de plugins activés par utilisateur. Les plugins doivent être activés manuellement. Les données peuvent quitter la limite de conformité. Orchestrator ne peut raisonner qu’avec 10 plugins par invite. Les performances dépendent des développeurs & l’hébergement.
Limitations de l’expérience des développeursAucun outil pour Visual Studio & VS Code. Aucun chargement indépendant. Vous devez rester synchronisé avec la liste de contrôle d’accès (ACL) manuellement si vous êtes dans des groupes externes en dehors du groupe Id Entra (Azure AD)Courbe d’apprentissage abrupte.
Plus de temps pour développer.
Vous devez gérer les invites à paramètres multiples.
Plus d’informationsLimites de l’API connecteurs GraphConditions techniques requises pour les plugins d’extension de message

Important : il n’est pour l’instant pas possible d’acheter et de provisionner des licences acheter Copilot for Microsoft 365 sur un tenant créé à partir du Microsoft 365 Developer Program.

Et Copilot Studio dans tout ça ?

Pas de secret, Microsoft Copilot Studio s’appuie déjà sur du connu et reconnu ! 😎🙏

Un grand merci à Elliott Pierret pour cette vidéo très explicative sur comment jouer avec Copilot Studio pour créer son propre Copilot ou enrichir un Copilot existant grâce aux outils suivants :

  • Copilot Builder
  • Plugin Builder
  • Prompt Builder

Conclusion

Quelle que soit votre stratégie Copilot, l’objectif de cette IA générative est avant tout de simplifier la vie à vos utilisateurs. Beaucoup de tâches sans grande valeur ajoutée peuvent et ont également intérêt à être traitées par l’intelligence artificielle.

Je vous invite à regarder cette interview très intéressante de Jean-François Bérenguer faite par Seyfallah Tagrerout sur le potentiel de Copilot et les services IT possibles avec une valeur ajoutée pour les entreprises dans leur transition vers l’IA :

  • Accompagnement au prompt
  • Mise en place du gouvernance de la donnée (protection)
  • Personnalisation de Copilot (Connecteurs, plugins)

Attendez-vous très prochainement à voir plusieurs articles sur des essais pratiques de Copilot 😎

Premiers pas dans l’IA

A la suite du Microsoft Learn Cloud Skills Challenge de 2023, Microsoft a continué les évènements liés à l’apprentissage avec le Microsoft Learn AI Skills Challenge, qui vient juste de se terminer il y a quelques jours.

L’un comme pour l’autre, leur but est de vous plonger dans l’apprentissage de produits Microsoft mais aussi de nouvelles thématiques IT innovantes.

IBM, Google, Amazon, NVIDIA, DataRobot, H2O.ai, OpenAI, Clarifai … ou encore Microsoft sont sur l’IA depuis plusieurs années, alors … pourquoi pas vous/moi ?

J’ai justement décidé de profiter de cet été pour m’y intéresser afin de me faire ma propre expérience.

Quelques termes fréquemment employés « à toutes les sauces » :

Certains termes liés à l’IA sont souvent employés à tout va. Prenons en exemple ces 3 là pour mieux les comprendre :

Source : Microsoft Learn :

  • Le Deep Learning, ou apprentissage profond, est un sous-ensemble du Machine Learning, ou apprentissage automatique, basé sur des réseaux neuronaux artificiels. Le processus d’apprentissage est qualifié de profond parce que la structure des réseaux neuronaux artificiels se compose de plusieurs couches d’entrée, de sortie et masquées.
  • Le Machine Learning est un sous-ensemble de l’intelligence artificielle utilisant des techniques (telles que le Deep Learning), qui permettent aux machines de tirer des enseignements de leur expérience pour améliorer la manière dont elles exécutent leurs tâches.
  • L’intelligence artificielle est une technique qui permet aux ordinateurs d’imiter l’intelligence humaine. Cette technique inclut donc le Machine Learning.

Sommes-nous vraiment face à une intelligence créative ou simplement générative ?

Alors pourquoi apprendre à utiliser des IAs ?

Comme le dirait très bien une IA :

Il y a plusieurs raisons pour lesquelles apprendre l’intelligence artificielle (IA) peut être bénéfique. L’IA occupe une place grandissante au sein des entreprises soucieuses d’innover et d’opérer leur transformation numériqueLes besoins en compétences relatives à cette technologie se font ainsi de plus en plus ressentir, créant de nombreuses opportunités professionnelles

Microsoft Copilot

Bref vous l’aurez compris, l’IA est même capable de s’autojustifier elle-même 🤣.

Les IAs restent une formidable boite à outils qui peuvent nous faire gagner un temps précieux dans certaines tâches.

D’ailleurs, les secteurs où les IAs œuvrent déjà ne manquent pas : marketing, santé, administratif, transport, …

Blog : doit-on encore écrire des articles « à la main » ?

Avec l’arrivée des agents conversationnels comme ChatGPT, cela devient une question légitime.

Ecrire un article sur un sujet technique est un travail long, et cela avant même le début de son écriture.

Mais la rédaction d’articles repose sur de la créativité : le sujet, les arguments, les contre-arguments, les exemples et les démonstrations.

Comment une IA générative ( et non créative) pourrait écrire et documenter quelque chose qui n’existe pas encore ou est encore insuffisamment documenté dans sa base de données ?

Bref IAs, ou pas IAs, ce sujet reste passionnant 😉

Petite vidéo intéressante sur ChatGPT :

Par où commencer ?

Le contenu d’apprentissage sur les IA est déjà vaste et conséquent. Avant de partir sur Azure, il est important de commencer avec certaines bases sur l’IA.

J’ai beaucoup apprécié les vidéos faites par IBM, disponibles ici sur YouTube et dont en voici certaines :

Microsoft a mis également à disposition plusieurs parcours d’apprentissage liés à l’IA juste ici :

Enfin et même si le Machine Learning Challenge est maintenant terminé, il est encore possible de suivre son contenu sur Microsoft Learn par ce lien :

Peut-on tester l’IA avec Azure ?

C’est justement le but de ce premier article sur le sujet, tester ensemble un premier service d’IA disponible sur Azure. Comme bien souvent, je trouve très intéressant d’utiliser les exercices Azure liés aux certifications. Microsoft les met à disposition sur sa plate-forme GitHub.

Voici donc la liste des exercices créés par Microsoft et en relation avec la première certification dédiée à l’AI : AI-900 :

Aussi je vous propose dans cet article de réaliser un premier exercice appelé Explorer la détection d’objets :

Etape 0 – Rappel des prérequis :

Pour réaliser cet exercice proposé par Microsoft et basé sur une IA d’Azure, il vous faudra disposer de :

  • Un tenant Microsoft
  • Une souscription Azure valide

Etape I Création de la ressource Azure Cognitive Services :

Nous allons utiliser ici un service central d’IA disponible sur Azure : Cognitive Services.

Mais pour la reconnaissance d’objets, nous aurions pu utiliser Custom Vision. En effet, beaucoup de services dédiés à un type d’IA sont également disponibles sous Azure.

Pour cela, rendez-vous dans le portail d’Azure et utilisez la barre de recherche :

Renseignez tous les champs suivants, puis lancez la validation Azure :

Une fois la validation Azure réussie, lancez la création des ressources puis attendez environ une minute :

Une fois le déploiement terminé, cliquez-ici pour voir votre Cognitive Services :

Le menu ci-dessous contient deux éléments importants : Clés et Point de terminaison de votre ressource Cognitive Services :

Gardez votre onglet Azure ouvert, rendez vous à la page suivante pour vous connectez au service Custom Vision, puis authentifiez avec votre compte Azure :

Acceptez les conditions d’utilisation de Custom Vision :

Cliquez-ici pour démarrer un nouveau projet Custom Vision :

Nommez projet en le configurant comme ceci, puis cliquez sur Créer :

Notre environnement IA est maintenant en place. Mais nous avons besoin de lui dire quoi faire (quoi identifier) pour que celui-ci soit à mesure de reproduire la tâche par la suite.

Etape II – Ajouts d’images étiquetées :

Pour que votre IA soit en mesure d’effectuer de la détection d’objet, elle a besoin d’être aidée lors de la phase d’identification.

En effet, l’identification IA repose avant tout sur un entrainement préalable.

Pour cela, il vous faut :

  • Télécharger des images contenant les classes que vous souhaitez que le modèle identifie.
  • Etiquetez des objets en délimitant les zones de chacun d’eux.

Une fois l’archive ZIP téléchargée, décompressez les fichiers JPG présents sur un dossier local :

Ajoutez les images d’entrainement en cliquant ici :

Validez l’envoi des 33 fichiers dans votre service Custom Vision en cliquant ici :

Attendez quelques minutes que le traitement d’envoi se termine :

Environ 2 minutes plus tard, fermez le traitement d’importation :

Cliquez sur la première image afin d’y rajoutez une ou plusieurs étiquettes Cycliste ou Piéton, selon les cas :

Sur chaque personne, choisissez le rectangle proposé par défaut ou dessinez-le avant de mettre l’étiquette appropriée (Cycliste / Piéton), puis cliquez ici pour passer sur l’image suivante :

Effectuez la même opération sur la totalité des photos téléversées (33) :

Une fois toutes les images étiquetées, retrouvez les deux classifications juste ici :

On a donné les informations de départ pour l’identification d’objets. Notre IA a maintenant besoin d’analyser les photos étiquetées pour comprendre les traits communs afin de créer la meilleure formulation possible.

Etape III – Entrainement de notre modèle d’IA :

Afin de familiariser notre IA aux photos étiquetées, Microsoft propose une fonction d’entrainement. A la différence de la phase de test qui suivra, cette étape permet de comprendre et formuler la détection et l’identification des objets.

Pour cela, cliquez sur Entrainer :

Sélectionnez l’option Formation rapide, puis cliquez sur Entrainer :

Attendez quelques minutes que le traitement se termine.

Pendant l’entrainement, il est possible de faire varier le curseur dédié au Seuil de probabilité. Comme son nom l’indique, le Seuil de probabilité correspond au minimum pour considérer la prédiction comme étant valide dans les calculs de Precision et de Recall :

A la fin du traitement, 3 indicateurs font leur apparition suite à l’entrainement :

  • Précision : Quelle est la proportion d’identifications positives réellement correctes ?
  • Recall : Quelle est la proportion de positifs réels qui a été identifiée correctement ?
  • mAP : Précision moyenne calculée comme la moyenne pondérée des précisions à chaque seuil

Notre modèle d’IA est maintenant entrainé. Un petit test s’impose avant sa publication afin d’être sûr que les systèmes fonctionnent bien.

Etape IV – Test rapide de notre modèle d’IA :

Avant de publier les API pour exploiter notre IA dans l’application, il est encore possible d’effectuer de test avec un ou plusieurs images entièrement nouvelles donc inconnues pour notre IA.

Pour cela, cliquez-ici :

Renseignez l’URL suivante, puis lancez le traitement d’analyse :

https://raw.githubusercontent.com/jlou07/ai/6071c0170056f5159aff1c6a4f612d809c8af5f5/cyclistes.jpg

L’image de test s’affiche alors et encadre en rouge les cyclistes ou piétons identifiés dans votre image. Un score de probabilité est aussi calculé pour chaque objet identifié :

Fermez la fenêtre de test rapide. Il nous est maintenant possible de publier notre modèle de détection des cyclistes et des piétons.

La publication active et autorise l’utilisation de notre modèle via le couple URL / clef.

Etape V – Publication et test réel de notre modèle d’IA :

Cliquez sur Publier pour rendre accessible notre model d’IA via son URL :

Définissez la ressource Cognitive Services créée précédemment, puis cliquez sur Publier :

Quelques secondes plus tard, notre model d’IA est enfin publié, l’URL que nous allons utiliser se trouve juste ici :

Retournez sur le portail Azure, puis ouvrez Azure Cloud Shell :

Si cela n’était pas déjà le cas, Azure Cloud Shell a besoin d’un compte de stockage Azure.

Cliquez-ici pour configurer le compte de stockage Azure pour le Cloud Shell :

Renseignez les différents champs selon vos souhaits, puis cliquez sur Créer :

Environ une minute plus tard, le message suivant apparaît. Choisissez PowerShell :

Saisissez les deux commandes suivantes pour nettoyer l’Azure Cloud Shell, et télécharger depuis GitHub les scripts utilisés pour les exercices présents dans l’AI-900 :

rm -r ai-900 -f
git clone https://github.com/MicrosoftLearning/AI-900-AIFundamentals ai-900

Lancez la commande suivante pour ouvrir le script detect-objects.ps1 dans l’éditeur Code :

cd ai-900
code detect-objects.ps1

Le script suivant apparaît alors, nous allons devoir modifier deux variables :

Pour que le script utilise bien votre model publié, identifiez champs suivants situés en haut du script :

Retournez sur la page de Custom Vision afin de copier / coller vos deux valeurs :

Cela doit donner la chose suivante :

Ensuite, lancez les deux commandes claviers suivantes :

  • CTRL + S : pour sauvegarder le script detect-objects.ps1 modifié.
  • CTRL + Q : pour quitter l’éditeur Code.

L’éditeur Code doit se fermer, gardez la fenêtre d’Azure Cloud Shell encore ouverte :

Testons l’image suivante au travers de notre modèle d’IA :

Pour cela, lancez le script suivant depuis votre fenêtre Azure Cloud Shell :

./detect-objects.ps1 1

Constatez les résultats de probabilité calculé par votre modèle :

Effectuez à nouveau l’exercice avec cette seconde image :

Pour cela, lancez ce second script depuis votre fenêtre Azure Cloud Shell :

./detect-objects.ps1 2

Constatez à nouveau les résultats de probabilité calculé par votre modèle :

Bien évidemment, votre modèle d’IA est encore imprécis et nécessitera beaucoup plus d’images pour améliorer sa précision de classification et sa probabilité de détection.

Mais c’est déjà un bon début pour comprendre comment un service d’IA, disponible sur étagère, peut faire gagner un temps précieux dans la conception d’applications.

Conclusion

Je ne peux que vous encourage qu’à tester l’IA d’Azure au travers des autres exercices disponibles sur cette liste.

A mon sens, Azure Cognitives Services et Azure Machine Learning sont de formidables outils simples d’utilisation et vous donneront une meilleure compréhension des systèmes d’IA.

Enfin, n’oubliez pas de prendre le temps de regarder des vidéos, d’assister à des trainings et de lire des articles provenant de différentes sources pour vous faire une meilleure idée de toutes les IAs passées, présentes et futures 😎.