Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Questa guida pratica illustra la programmazione probabilistica usando Infer.NET. La programmazione probabilistica è un approccio di Machine Learning in cui i modelli personalizzati vengono espressi come programmi informatici. Consente di incorporare le conoscenze di dominio nei modelli e rende il sistema di Machine Learning più interpretabile. Supporta anche l'inferenza online: il processo di apprendimento man mano che arrivano nuovi dati. Infer.NET viene usato in vari prodotti microsoft in Azure, Xbox e Bing.
Che cos'è la programmazione probabilistica?
La programmazione probabilistica consente di creare modelli statistici di processi reali.
Prerequisiti
Ambiente di sviluppo locale.
Questa guida pratica prevede di avere un computer che è possibile usare per lo sviluppo. L'esercitazione su .NET Hello World in 10 minuti contiene istruzioni per configurare l'ambiente di sviluppo locale in macOS, Windows o Linux.
Creare l'app
Aprire un nuovo prompt dei comandi ed eseguire i comandi seguenti:
dotnet new console -o myApp
cd myApp
Il dotnet comando crea un'applicazione new di tipo console. Il -o parametro crea una directory denominata myApp in cui è archiviata l'app e la popola con i file necessari. Il comando cd myApp ti porta nella directory dell'app appena creata.
Installare Infer.NET pacchetto
Per usare Infer.NET, è necessario installare il Microsoft.ML.Probabilistic.Compiler pacchetto. Nel prompt dei comandi eseguire il comando seguente:
dotnet add package Microsoft.ML.Probabilistic.Compiler
In alternativa, in .NET 10+:
dotnet package add Microsoft.ML.Probabilistic.Compiler
Progettare il modello
L'esempio usa il tennis da tavolo o le partite di foosball giocato in ufficio. Si hanno i partecipanti e il risultato di ogni partita. Si vogliono dedurre le competenze del giocatore da questi dati. Si supponga che ogni giocatore abbia un'abilità latente normalmente distribuita e che le prestazioni nelle partite fornite siano una versione alterata di questa abilità. I dati vincolano le prestazioni del vincitore a essere superiori alle prestazioni del perdente. Si tratta di una versione semplificata del popolare modello TrueSkill, che supporta anche squadre, pareggi e altre estensioni. Una versione avanzata di questo modello viene usata per il matchmaking nei titoli di gioco più venduti Halo e Gears of War.
È necessario elencare le abilità dei giocatori dedotti, insieme alla loro varianza– la misura dell'incertezza intorno alle abilità.
Dati di esempio dei risultati del gioco
| Gioco | Vincitore | Perdente |
|---|---|---|
| 1 | Giocatore 0 | Giocatore 1 |
| 2 | Giocatore 0 | Giocatore 3 |
| 3 | Giocatore 0 | Giocatore 4 |
| 4 | Giocatore 1 | Giocatore 2 |
| 5 | Giocatore 3 | Giocatore 1 |
| 6 | Giocatore 4 | Giocatore 2 |
Esaminando più da vicino i dati di esempio, si noterà che i giocatori 3 e 4 hanno una vittoria e una perdita. Vediamo come appaiono le classificazioni usando la programmazione probabilistica. Si noti anche che c'è un giocatore zero perché anche gli elenchi di confronto dell'ufficio partono da zero per noi sviluppatori.
Scrivere codice
Dopo aver progettato il modello, è il momento di esprimerlo come programma probabilistico usando l'API di modellazione Infer.NET. Apri Program.cs nell'editor di testo preferito e sostituisci tutto il relativo contenuto con il codice seguente:
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}");
}
}
}
}
Avvia la tua app
Nel prompt dei comandi eseguire il comando seguente:
dotnet run
Risultati
I risultati dovrebbero essere simili ai seguenti:
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)
Nei risultati si noti che il giocatore 3 è leggermente superiore al giocatore 4 in base al modello. Ciò è dovuto al fatto che la vittoria del giocatore 3 su 1 è più significativa della vittoria del giocatore 4 su 2– si noti che il giocatore 1 batte il giocatore 2. Il giocatore 0 è il campione complessivo!
Continuare a imparare
La progettazione di modelli statistici è una competenza da sola. Il team di Microsoft Research Cambridge ha scritto un libro online gratuito, che offre un'introduzione gentile all'articolo. Il capitolo 3 di questo libro illustra in modo più dettagliato il modello TrueSkill. Una volta creato un modello, è possibile trasformarlo in codice usando la documentazione completa sul sito Web di Infer.NET.
Passaggi successivi
Vedere il repository GitHub Infer.NET per continuare a imparare e trovare altri esempi.
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
