Core ML 2 dans Xamarin.iOS

  • Article

Core ML est une technologie de Machine Learning disponible sur iOS, macOS, tvOS et watchOS. Il permet aux applications d’effectuer des prédictions basées sur des modèles Machine Learning.

Dans iOS 12, Core ML inclut une API de traitement par lots. Cette API rend Core ML plus efficace et fournit des améliorations de performances dans les scénarios où un modèle est utilisé pour effectuer une séquence de prédictions.

Exemple d’application : MarsHabitatCoreMLTimer

Pour illustrer les prédictions par lots avec Core ML, consultez l’exemple d’application MarsHabitatCoreMLTimer . Cet échantillon utilise un modèle DE ML de base entraîné pour prédire le coût de la construction d’un habitat sur Mars, en fonction de diverses entrées : nombre de panneaux solaires, nombre de serres et nombre d’acres.

Les extraits de code de ce document proviennent de cet exemple.

Générer un exemple de données

Dans ViewController, la méthode de ViewDidLoad l’exemple d’application appelle LoadMLModel, qui charge le modèle Core ML inclus :

void LoadMLModel()
{
    var assetPath = NSBundle.MainBundle.GetUrlForResource("CoreMLModel/MarsHabitatPricer", "mlmodelc");
    model = MLModel.Create(assetPath, out NSError mlErr);
}

Ensuite, l’exemple d’application crée 100 000 MarsHabitatPricerInput objets à utiliser comme entrée pour les prédictions Core ML séquentielles. Chaque échantillon généré a une valeur aléatoire définie pour le nombre de panneaux solaires, le nombre de serres et le nombre d’acres :

async void CreateInputs(int num)
{
    // ...
    Random r = new Random();
    await Task.Run(() =>
    {
        for (int i = 0; i < num; i++)
        {
            double solarPanels = r.NextDouble() * MaxSolarPanels;
            double greenHouses = r.NextDouble() * MaxGreenHouses;
            double acres = r.NextDouble() * MaxAcres;
            inputs[i] = new MarsHabitatPricerInput(solarPanels, greenHouses, acres);
        }
    });
    // ...
}

Appuyez sur l’un des trois boutons de l’application pour exécuter deux séquences de prédictions : l’une utilisant une for boucle et l’autre utilisant la nouvelle méthode de traitement par lots GetPredictions introduite dans iOS 12 :

async void RunTest(int num)
{
    // ...
    await FetchNonBatchResults(num);
    // ...
    await FetchBatchResults(num);
    // ...
}

for (boucle)

La for version de boucle du test itère naïvement sur le nombre spécifié d’entrées, en appelant GetPrediction pour chacune d’elles et en ignorant le résultat. La méthode met en temps le temps nécessaire pour effectuer les prédictions :

async Task FetchNonBatchResults(int num)
{
    Stopwatch stopWatch = Stopwatch.StartNew();
    await Task.Run(() =>
    {
        for (int i = 0; i < num; i++)
        {
            IMLFeatureProvider output = model.GetPrediction(inputs[i], out NSError error);
        }
    });
    stopWatch.Stop();
    nonBatchMilliseconds = stopWatch.ElapsedMilliseconds;
}

GetPredictions (nouvelle API batch)

La version par lot du test crée un MLArrayBatchProvider objet à partir du tableau d’entrée (étant donné qu’il s’agit d’un paramètre d’entrée obligatoire pour la GetPredictions méthode), crée un objetMLPredictionOptions objet qui empêche les calculs de prédiction d’être limités au processeur et utilise l’API GetPredictions pour extraire les prédictions, en ignorant à nouveau le résultat :

async Task FetchBatchResults(int num)
{
    var batch = new MLArrayBatchProvider(inputs.Take(num).ToArray());
    var options = new MLPredictionOptions()
    {
        UsesCpuOnly = false
    };

    Stopwatch stopWatch = Stopwatch.StartNew();
    await Task.Run(() =>
    {
        model.GetPredictions(batch, options, out NSError error);
    });
    stopWatch.Stop();
    batchMilliseconds = stopWatch.ElapsedMilliseconds;
}

Résultats

Sur le simulateur et l’appareil, GetPredictions se termine plus rapidement que les prédictions Core ML basées sur une boucle.