Créer une application de tableau de matchs avec Infer.NET et la programmation probabiliste

2025-06-29

Ce guide pratique vous apprend à propos de la programmation probabiliste à l’aide de Infer.NET. La programmation probabiliste est une approche de Machine Learning où les modèles personnalisés sont exprimés en tant que programmes informatiques. Il permet d’incorporer des connaissances de domaine dans les modèles et rend le système Machine Learning plus interprétable. Il prend également en charge l’inférence en ligne : le processus d’apprentissage à mesure que de nouvelles données arrivent. Infer.NET est utilisé dans différents produits chez Microsoft dans Azure, Xbox et Bing.

Qu’est-ce que la programmation probabiliste ?

La programmation probabiliste vous permet de créer des modèles statistiques de processus réels.

Conditions préalables

Environnement de développement local.

Ce guide pratique s’attend à ce que vous disposiez d’un ordinateur que vous pouvez utiliser pour le développement. Le didacticiel .NET Hello World en 10 minutes contient des instructions pour configurer votre environnement de développement local sur macOS, Windows ou Linux.

Créer votre application

Ouvrez une nouvelle invite de commandes et exécutez les commandes suivantes :

dotnet new console -o myApp
cd myApp

La dotnet commande crée une new application de type console. Le -o paramètre crée un répertoire nommé myApp où votre application est stockée et la remplit avec les fichiers requis. La cd myApp commande vous place dans le répertoire d’application nouvellement créé.

Installer le paquet Infer.NET

Pour utiliser Infer.NET, vous devez installer le Microsoft.ML.Probabilistic.Compiler package. Dans votre invite de commandes, exécutez la commande suivante :

dotnet add package Microsoft.ML.Probabilistic.Compiler

Ou, dans .NET 10+ :

dotnet package add Microsoft.ML.Probabilistic.Compiler

Concevoir votre modèle

L’exemple utilise des matchs de tennis de table ou de foosball joués dans le bureau. Vous avez les participants et les résultats de chaque match. Vous souhaitez déduire les compétences du joueur à partir de ces données. Supposons que les compétences latentes de chaque joueur suivent une distribution normale, et que leurs performances dans un match donné représentent une version bruitée de cette compétence. Les données limitent les performances du gagnant à être supérieures aux performances du perdant. Il s’agit d’une version simplifiée du modèle populaire TrueSkill, qui prend également en charge les équipes, les matches nuls, et autres extensions. Une version avancée de ce modèle est utilisée pour la mise en correspondance dans les titres de jeu les plus vendus Halo et Gears of War.

Vous devez répertorier les compétences déduites des joueurs, en plus de leur variance : la mesure de l’incertitude autour des compétences.

Exemples de données de résultats de jeu

Jeu	Gagnant	Perdant
1	Joueur 0	Joueur 1
2	Joueur 0	Joueur 3
3	Joueur 0	Joueur 4
4	Joueur 1	Joueur 2
5	Joueur 3	Joueur 1
6	Joueur 4	Joueur 2

Avec un examen plus approfondi des exemples de données, vous remarquerez que les joueurs 3 et 4 ont une victoire et une perte. Voyons à quoi ressemblent les classements à l’aide de la programmation probabiliste. À noter également la présence d’un joueur 0, car on part toujours de zéro dans une tâche de développement.

Écrire du code

Après avoir conçu le modèle, il est temps de l’exprimer en tant que programme probabiliste à l’aide de l’API de modélisation Infer.NET. Ouvrez Program.cs dans votre éditeur de texte favori et remplacez tout son contenu par le code suivant :

namespace myApp

{
    using System;
    using System.Linq;
    using Microsoft.ML.Probabilistic;
    using Microsoft.ML.Probabilistic.Distributions;
    using Microsoft.ML.Probabilistic.Models;

    class Program
    {

        static void Main(string[] args)
        {
            // The winner and loser in each of 6 samples games
            var winnerData = new[] { 0, 0, 0, 1, 3, 4 };
            var loserData = new[] { 1, 3, 4, 2, 1, 2 };

            // Define the statistical model as a probabilistic program
            var game = new Range(winnerData.Length);
            var player = new Range(winnerData.Concat(loserData).Max() + 1);
            var playerSkills = Variable.Array<double>(player);
            playerSkills[player] = Variable.GaussianFromMeanAndVariance(6, 9).ForEach(player);

            var winners = Variable.Array<int>(game);
            var losers = Variable.Array<int>(game);

            using (Variable.ForEach(game))
            {
                // The player performance is a noisy version of their skill
                var winnerPerformance = Variable.GaussianFromMeanAndVariance(playerSkills[winners[game]], 1.0);
                var loserPerformance = Variable.GaussianFromMeanAndVariance(playerSkills[losers[game]], 1.0);

                // The winner performed better in this game
                Variable.ConstrainTrue(winnerPerformance > loserPerformance);
            }

            // Attach the data to the model
            winners.ObservedValue = winnerData;
            losers.ObservedValue = loserData;

            // Run inference
            var inferenceEngine = new InferenceEngine();
            var inferredSkills = inferenceEngine.Infer<Gaussian[]>(playerSkills);

            // The inferred skills are uncertain, which is captured in their variance
            var orderedPlayerSkills = inferredSkills
               .Select((s, i) => new { Player = i, Skill = s })
               .OrderByDescending(ps => ps.Skill.GetMean());

            foreach (var playerSkill in orderedPlayerSkills)
            {
                Console.WriteLine($"Player {playerSkill.Player} skill: {playerSkill.Skill}");
            }
        }
    }
}

Exécuter votre application

Dans votre invite de commandes, exécutez la commande suivante :

dotnet run

Résultats

Vos résultats doivent être similaires à ce qui suit :

Compiling model...done.
Iterating:
.........|.........|.........|.........|.........| 50
Player 0 skill: Gaussian(9.517, 3.926)
Player 3 skill: Gaussian(6.834, 3.892)
Player 4 skill: Gaussian(6.054, 4.731)
Player 1 skill: Gaussian(4.955, 3.503)
Player 2 skill: Gaussian(2.639, 4.288)

Dans les résultats, notez que le joueur 3 se classe légèrement plus haut que le joueur 4 selon le modèle. C’est parce que la victoire du joueur 3 sur le joueur 1 est plus importante que la victoire du joueur 4 sur le joueur 2 – notez que le joueur 1 bat le joueur 2. Le joueur 0 est le champion global !

Continuer à apprendre

La conception de modèles statistiques est une compétence propre. L’équipe Microsoft Research Cambridge a écrit un livre en ligne gratuit, qui donne une présentation douce de l’article. Le chapitre 3 de ce livre couvre plus en détail le modèle TrueSkill. Une fois que vous avez un modèle à l’esprit, vous pouvez le transformer en code à l’aide de la documentation complète sur le site web Infer.NET.

Étapes suivantes

Consultez le dépôt GitHub Infer.NET pour continuer à apprendre et trouver d’autres exemples.

dotnet/infer GitHub dépôt

Partager via