CoreML Espace de noms

L’espace de noms CoreML fournit un accès relativement élevé aux runtimes de modèle Machine Learning.

Classes

MLArrayBatchProvider	adossé IMLBatchProvider à un tableau.
MLCustomLayer_Extensions	Implémentations par défaut pour les méthodes facultatives dans le IMLCustomLayer protocole.
MLCustomModel	Implémentation par défaut de IMLCustomModel.
MLCustomModel_Extensions	Implémentations par défaut pour les méthodes facultatives dans le MLCustomModel protocole.
MLDictionaryConstraint	Contient une valeur qui limite le type de clés de dictionnaire.
MLDictionaryFeatureProvider	Implémentation de IMLFeatureProvider qui est soutenue par un NSDictionary.
MLFeatureDescription	Description explicite pour le développeur d’une MLModel fonctionnalité.
MLFeatureValue	Valeur immuable et MLFeatureType pour une fonctionnalité.
MLImageConstraint	Contient des contraintes pour une fonctionnalité d’image.
MLImageSize	Décrit une taille d’image acceptable pour les entrées de modèle CoreML.
MLImageSizeConstraint	Description de la contrainte sur les tailles d’image pour un modèle CoreML.
MLModel	Encapsule un modèle Machine Learning entraîné.
MLModelConfiguration	L’espace de noms CoreML fournit un accès relativement élevé aux runtimes de modèle Machine Learning.
MLModelDescription	Description significative du développeur de .MLModel
MLModelErrorExtensions	Méthodes d’extension pour l’énumération CoreML.MLModelError.
MLModelMetadata	DictionaryContainer qui contient des métadonnées liées à un MLModel.
MLMultiArray	Représente un tableau multidimensionnel efficace.
MLMultiArrayConstraint	Contient des contraintes pour une fonctionnalité de tableau multidimensionnel.
MLMultiArrayShapeConstraint	Décrit les contraintes sur la forme du tableau multidimensionnel autorisé par le modèle.
MLPredictionOptions	Contient une valeur qui indique s’il faut limiter les calculs de prédiction au processeur.
MLSequence	Encode une séquence en tant qu’entrée unique.
MLSequenceConstraint	Contrainte sur les séquences de fonctionnalités.

Interfaces

IMLBatchProvider	Interface définissant le protocole pour fournir des données par lots au modèle.
IMLCustomLayer	Interface définissant les méthodes nécessaires pour une couche de modèle personnalisée.
IMLCustomModel	Interface définissant un modèle CoreML personnalisé.
IMLFeatureProvider	Interface qui définit les fonctionnalités d’entrée ou de sortie et autorise l’accès à leurs valeurs.

Énumérations

MLComputeUnits	L’espace de noms CoreML fournit un accès relativement élevé aux runtimes de modèle Machine Learning.
MLFeatureType	Énumère les types de fonctionnalités prises en charge par CoreML.
MLImageSizeConstraintType	Énumère la forme d’un MLImageSizeConstraint.
MLModelError	Énumère les erreurs qui peuvent se produire lors de l’utilisation de Core ML.
MLMultiArrayDataType	Énumère les types de valeurs stockées dans un MLMultiArray.
MLMultiArrayShapeConstraintType	Énumère la forme d’un MLMultiArrayShapeConstraint.

Remarques

L’espace de noms CoreML, introduit dans iOS 11, permet l’interrogation au runtime d’une grande variété de modèles Machine Learning produits par des frameworks tels que scipy-learn, TensorFlow et Azure Custom Vision cognitive Services. CoreML ne prend pas en charge la modification sur l’appareil des modèles ou des poids, mais il prend en charge le chargement d’un modèle à partir d’une URL. Les développeurs peuvent donc l’utiliser pour télécharger des modèles mis à jour.

CoreML s’appuie sur un « modèle » distribué sous la forme d’un fichier .mlmodel unique. Ce modèle est compilé dans un formulaire utilisable à l’aide d’outils intégrés dans Xcode, Xamarin Studio ou en ligne de commande. Sur la ligne de commande, un fichier .mlmodel peut être compilé avec xcrun coremlcompiler compile model.mlmodel outputfolder . Un modèle compilé prend la forme d’un répertoire appelé modelname.mlmodelc . Le modèle est ensuite chargé au moment de l’exécution avec un code similaire à ce qui suit :

var bundle = NSBundle.MainBundle;
var assetPath = bundle.GetUrlForResource("MarsHabitatPricer", "mlmodelc");
NSError mlErr;
model = MLModel.Create(assetPath, out mlErr);

Les modèles dans CoreML sont assez « opaques box » et n’ont pas d’API étendue. Au lieu de cela, le développeur iOS doit connaître les noms et types d’entrée et de sortie attendus par le modèle. Par exemple, un modèle de reconnaissance d’image peut s’attendre à un CVPixelBuffer de taille 227 x 227 identifié comme « image » et peut avoir deux sorties : une chaîne identifiée comme « classLabel » et une NSDictionary avec NSString des clés et double

valeurs dans la plage [0,1] représentant la confiance de la prédiction.

Les développeurs doivent convertir leurs représentations natives en instances compatibles CoreML de IMLFeatureProvider . La façon la plus simple d’effectuer cette opération est d’utiliser un MLDictionaryFeatureProvider :

CVPixelBuffer pixelBuffer = // from image or video stream
var imageValue = MLFeatureValue.Create(pixelBuffer);

var inputs = new NSDictionary<NSString, NSObject>(new NSString("image"), imageValue);

NSError error, error2;
var inputFp = new MLDictionaryFeatureProvider(inputs, out error);
if(error != null)
{
	ErrorOccurred(this, new EventArgsT<string>(error.ToString()));
	return;
}
var outFeatures = model.GetPrediction(inputFp, out error2);
if(error2 != null)
{
	ErrorOccurred(this, new EventArgsT<string>(error2.ToString()));
	return;
}

var predictionsDictionary = outFeatures.GetFeatureValue("classLabelProbs").DictionaryValue;

Une méthode plus complexe, mais plus flexible, consiste à implémenter IMLFeatureProvider :

public class MarsHabitatPricerInput : NSObject, IMLFeatureProvider
{
	public double SolarPanels { get; set; }
	public double Greenhouses { get; set; }
	public double Size { get; set; }

	public NSSet<NSString> FeatureNames => new NSSet<NSString>(new NSString("solarPanels"), new NSString("greenhouses"), new NSString("size"));

	public MLFeatureValue GetFeatureValue(string featureName)
	{
		switch (featureName)
		{
			case "solarPanels":
				return MLFeatureValue.Create(SolarPanels);
			case "greenhouses":
				return MLFeatureValue.Create(Greenhouses);
			case "size":
				return MLFeatureValue.Create(Size);
			default:
				return MLFeatureValue.Create(0);
		}
	}
}

L’obtention d’une prédiction se produit de manière synchrone, avec un appel à GetPrediction :

NSError prErr;
IMLFeatureProvider outFeatures = model.GetPrediction(pricerInput, out prErr);
double result = outFeatures.GetFeatureValue("price").DoubleValue;

CoreML prend actuellement en charge :

Type	Variantes	Produit par :
Réseaux neuronaux	Convolutation, feed-forward, récurrent	Caffe, Keras, Azure Custom Vision
Ensembles d’arborescences	Forêts aléatoires, arbres boostés, arbres de décision	scikit-learn, XGBoost
Machines à vecteurs de support (SVM)	Scalaire et multiclasse	scikit-learn, LIBSVM
Modèles linéaires généralisés	Régression linéaire et logistique	scikit-learn
Modèles de pipeline	Modèles chaînés séquentiellement	scikit-learn

Apple dispose d’outils Python open source (licence BSD à 3 clauses) pour créer des modèles CoreML : https://pypi.python.org/pypi/coremltools

Voir aussi

• https://github.com/xamarin/ios-samples/blob/master/ios11/CoreML
• https://github.com/xamarin/ios-samples/blob/master/ios11/CoreMLAzureModel
• https://github.com/xamarin/ios-samples/blob/master/ios11/CoreMLImageRecognition
• https://github.com/xamarin/ios-samples/blob/master/ios11/CoreMLVision