Partager via

Core ML 2 dans Xamarin.iOS

  • Article

Core ML est une technologie machine learning disponible sur iOS, macOS, tvOS et watchOS. Elle 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 améliore les performances dans les scénarios où un modèle est utilisé pour effectuer une séquence de prédictions.

Générer un exemple de données

Dans ViewController, l’exemple d’appel LoadMLModelde méthode de ViewDidLoad l’application, 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);
        }
    });
    // ...
}

En appuyant sur l’un des trois boutons de l’application, deux séquences de prédictions sont exécutées : une à l’aide d’une for boucle et une autre à l’aide de la nouvelle méthode de traitement 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 naivement sur le nombre d’entrées spécifié, appelant GetPrediction chacun et dis carte le résultat. La méthode prend 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 (car il s’agit d’un paramètre d’entrée requis pour la GetPredictions méthode), crée un objet MLPredictionOptionsobjet qui empêche les calculs de prédiction d’être limités à l’UC et utilise l’API GetPredictions pour extraire les prédictions, à nouveau dis carte ing the result :

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 la boucle.