Microsoft .NET Core – Découverte de Microsoft Machine Learning (vers l’intelligence artificielle)

Avec le concept de Machine Learning, les logiciels apprennent par eux-mêmes, peuvent prendre des décisions, à partir de données contenues dans une base de données ou fournies par un service Web. La frontière vers l’intelligence artificielle est alors très proche.

Cet article a pour but de mettre en œuvre dans un simple exemple le Framework proposé par Microsoft, nommé Machine Learning, Il consiste à déterminer si un ensemble de phrases, fourni par un utilisateur, révèle une opinion positive ou négative.

Comment est-ce possible ? Nous allons fournir au Framework Machine Learning 1000 phrases, rédigées en français, avec pour chacune d’entre elles, un indicateur d’opinion (0 ou 1) négative ou positive. Voici quelques exemples de phrases (les indicateurs sont séparés des phrases par une tabulation) :

  • Cet achat est une énorme déception !! 0
  • L’installation s’est très bien passée. 1
  • Il est bien fait, facile d’accès au téléphone et dispose d’un clip ceinture amovible et pratique. 1
  • Impossible de télécharger les fichiers d’un tiers. 0

Puis nous utiliserons le Framework Machine Learning d’analyser ces données. Ensuite il sera en mesure d’analyser des phrases que nous lui donnerons afin de déterminer si elles dégagent un sentiment négatif ou positif.

Vous trouverez ci-dessous le code de l’application. Il s’agit d’un projet console ciblant le Framework .NET Core dans lequel a été ajout le package NuGet nommé Microsoft.ML. Ce projet est constitué de trois classes (Opinion, PredictionOpinion et Program). Voici leur implementation :

using System;
using Microsoft.ML.Models;
using Microsoft.ML.Runtime;
using Microsoft.ML.Runtime.Api;
using Microsoft.ML.Trainers;
using Microsoft.ML.Transforms;
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML;
using System.Text;

namespace PremiereApp
{
    /// <summary>
    /// Permet de charger en mémoire les phrases et l'opinion associées contenues dans le fichiers d'opinon.
    /// </summary>
    public class Opinion
    {
        /// <summary>
        /// Phrase.
        /// </summary>
        [Column("0")]
        public string Libelle;

        /// <summary>
        /// Indicateur d'opinion (0 : négative ; 1 : positive)
        /// </summary>
        [Column("1", "Label")]
        public float Valeur;

        /// <summary>
        /// Constructeur.
        /// </summary>
        /// <param name="aLibelle">Phrase</param>
        public Opinion(string aLibelle)
        {
            this.Libelle = aLibelle;
            this.Valeur = 0;
        }
    }
   
    /// <summary>
    /// Résultat de la prédiction d'une opinion sur une phrase.
    /// </summary>
    public class PredictionOpinion
    {
        /// <summary>
        /// Indicateur d'opinion (true : positive ; false : négative).
        /// </summary>
        [ColumnName("PredictedLabel")]
        public bool Valeur;
    }

    public class Program
    {
        /// <summary>
        /// Path du fichier contenant les phrases avec l'indicateur d'opinion
        /// </summary>
        private static string DataPath = @"data\Avis Produits.txt";

        static void Main(string[] args)
        {
            try
            {
                // Variables locales.
                LearningPipeline pipeline;
                PredictionModel<Opinion, PredictionOpinion> model;
                IEnumerable<Opinion> listeAvis;
                IEnumerable<PredictionOpinion> listeOpinions;

                // Initialisation.
                pipeline = new LearningPipeline();
                pipeline.Add(new TextLoader<Opinion>(DataPath, useHeader: false, separator: "tab"));
                pipeline.Add(new TextFeaturizer("Features", "Libelle"));
                pipeline.Add(new FastTreeBinaryClassifier() { NumLeaves = 5, NumTrees = 5, MinDocumentsInLeafs = 2 });

                // Construction du modèle.
                model = pipeline.Train<Opinion, PredictionOpinion>();

                // Jeu de données à analyser.
                listeAvis = new[] {
                    new Opinion("Ce produit est utile"),
                    new Opinion("Il marche de temps en temps et parfois pas du tout"),
                    new Opinion("Il ne m'a pas aidé")
                };

                Console.WriteLine();
                Console.WriteLine("Prédiction de l'opinion des avis");
                Console.WriteLine("---------------------");

                // Détermination de l'opinion des avis.
                listeOpinions = model.Predict(listeAvis);

                // Agrégation des données.
                var listeAvisAvecOpinion = listeAvis.Zip(listeOpinions, (sentiment, prediction) => (sentiment, prediction));

                // Parcours et affichage des données.
                foreach (var item in listeAvisAvecOpinion)
                {
                    Console.WriteLine($"Avis : {item.sentiment.Libelle} | Opinion : {(item.prediction.Valeur ? "Positive" : "Negative")}");
                }
            }
            catch (Exception aEx)
            {
                Console.WriteLine(aEx);
            }
            finally
            {
                Console.Read();
            }
        }
    }
}

About: James RAVAILLE

Travaillant avec la plateforme Microsoft .NET depuis 2002, j’alterne les missions de formation et d’ingénierie avec cette plateforme. J’écris ce blog pour transmettre mes connaissances à tout développeur, qu’il soit débutant ou expérimenté.