Utilisation de CNTK avec l’API C#/.NET

Article
08/30/2017

CNTK v2.2.0 fournit l’API C# pour générer, entraîner et évaluer des modèles CNTK. Cette section fournit une vue d’ensemble de l’API CNTK C#. Des exemples d’entraînement C# sont disponibles dans le référentiel github CNTK.

Utilisation de l’API managée C#/.NET pour créer un réseau neuronal profond

L’API C# C# CNTK fournit des opérations de base dans l’espace de noms CNTKLib. Une opération CNTK prend une ou deux variables d’entrée avec les paramètres nécessaires et produit une fonction CNTK. Une fonction CNTK mappe les données d’entrée à la sortie. Une fonction CNTK peut également être traitée comme une variable et être prise comme entrée dans une autre opération CNTK. Avec ce mécanisme, un réseau neuronal profond peut être créé avec des opérations CNTK de base en chaînant et en composition. Par exemple :

private static Function CreateLogisticModel(Variable input, int numOutputClasses)
{             
    Parameter bias = new Parameter(new int[]{numOutputClasses}, DataType.Float, 0}
    Parameter weights = new Parameter(new int[]{input.Shape[0], numOutputClasses}, DataType.Float,        
      CNTKLib.GlorotUniformInitializer( 
        CNTKLib.DefaultParamInitScale, 
        CNTKLib.SentinelValueForInferParamInitRank, 
        CNTKLib.SentinelValueForInferParamInitRank, 1));
    var z = CNTKLib.Plus(bias, CNTKLib.Times(weights, input));    
    Function logisticClassifier = CNTKLib.Sigmoid(z, "LogisticClassifier");
    return logisticClassifier;
}

CNTKLib.Plus, CNTKLib.Times, CNTKLib.Sigmoid sont des opérations CNTK de base. L’argument d’entrée peut être une variable CNTK représentant des fonctionnalités de données. Il peut également s’agir d’une autre fonction CNTK. Ce code génère un réseau de calcul simple avec des paramètres qui sont ajustés au stade de l’entraînement pour créer un classifieur multiclasse décent.

L’API CNTK C# fournit des opérations pour créer des réseaux neuronaux convolution (CNN) et des réseaux neuronaux récurrents (RNN). Par exemple, pour créer un classifieur d’image CNN à deux couches :

    var convParams1 = new Parameter(
      new int[] { kernelWidth1, kernelHeight1, numInputChannels, outFeatureMapCount1 }, 
      DataType.Float, CNTKLib.GlorotUniformInitializer(convWScale, -1, 2), device);
    var convFunction1 = CNTKLib.ReLU(CNTKLib.Convolution(
      convParams1, input, 
      new int[] { 1, 1, numInputChannels } ));
    var pooling1 = CNTKLib.Pooling(convFunction1, PoolingType.Max,
        new int[] { poolingWindowWidth1, poolingWindowHeight1 }, new int[] { hStride1, vStride1 }, new bool[] { true });
    
    var convParams2 = new Parameter(
      new int[] { kernelWidth2, kernelHeight2, outFeatureMapCount1, outFeatureMapCount2 }, 
      DataType.Float, CNTKLib.GlorotUniformInitializer(convWScale, -1, 2), device);
    var convFunction2 = CNTKLib.ReLU(CNTKLib.Convolution(
      convParams2, pooling1, 
      new int[] { 1, 1, outFeatureMapCount1 } ));
    var pooling2 = CNTKLib.Pooling(convFunction2, PoolingType.Max,
        new int[] { poolingWindowWidth2, poolingWindowHeight2 }, new int[] { hStride2, vStride2 }, new bool[] { true });

    var imageClassifier = TestHelper.Dense(pooling2, numClasses, device, Activation.None,   "ImageClassifier");

Un exemple de génération d’un RNN avec de la mémoire à court terme (LTSM) est également fourni.

Préparation des données à l’aide de C#/.NET

CNTK fournit des utilitaires de préparation des données pour l’entraînement. L’API CNTK C# expose ces utilitaires. Il prend des données de différents formulaires prétraite. Le chargement et le traitement par lots des données sont effectués efficacement. Par exemple, en supposant que nous avons des données dans le texte au format de texte CNTK suivant appelé « Train.ctf » :

|features 3.854499 4.163941 |labels 1.000000
|features 1.058121 1.204858 |labels 0.000000
|features 1.870621 1.284107 |labels 0.000000
|features 1.134650 1.651822 |labels 0.000000
|features 5.420541 4.557660 |labels 1.000000
|features 6.042731 3.375708 |labels 1.000000
|features 5.667109 2.811728 |labels 1.000000
|features 0.232070 1.814821 |labels 0.000000

Une source de données CNTK est créée de cette façon :

    var minibatchSource = MinibatchSource.TextFormatMinibatchSource(
        Path.Combine(DataFolder, "Train.ctf"), streamConfigurations,
        MinibatchSource.InfinitelyRepeat, true);

Les données batch peuvent être récupérées et utilisées pour l’entraînement ultérieurement :

    var minibatchData = minibatchSource.GetNextMinibatch(minibatchSize, device);

Utilisation de l’API managée C#/.NET pour entraîner un réseau neuronal profond

La descente de gradient stochastique (SGD) est un moyen d’optimiser les paramètres de modèle avec des données d’entraînement minibatch. CNTK prend en charge de nombreuses variantes SGD couramment observées dans la littérature d’apprentissage profond. Elles sont exposées par l’API CNTK C# :

SGDLearner - apprenant SGD intégré CNTK
MomentumSGDLearner - apprenant Momentum SGD intégré À CNTK
FSAdaGradLearner - une variante de l’apprenant AdaGrad
AdamLearner - apprenant Adam
AdaGradLearner - apprenant de dégradé adaptatif
RMSPropLearner - apprenant RMSProp
AdaDeltaLearner - apprenant AdaDelta

Pour obtenir une vue d’ensemble générale des différents optimiseurs d’apprentissage, consultez descente de gradient stochastique.

Un formateur CNTK est utilisé pour effectuer une formation minibatch. Un code C# snip pour l’entraînement minibatch :

    // build a learning model
    var featureVariable = Variable.InputVariable(new int[] { inputDim }, DataType.Float);
    var labelVariable = Variable.InputVariable(new int[] { numOutputClasses }, DataType.Float);
    var classifierOutput = CreateLinearModel(featureVariable, numOutputClasses, device);
    var loss = CNTKLib.CrossEntropyWithSoftmax(classifierOutput, labelVariable);
    var evalError = CNTKLib.ClassificationError(classifierOutput, labelVariable);

    // prepare for training
    var learningRatePerSample = new CNTK.TrainingParameterScheduleDouble(0.02, 1);
    var parameterLearners =
        new List<Learner>() { Learner.SGDLearner(classifierOutput.Parameters(), learningRatePerSample) };
    var trainer = Trainer.CreateTrainer(classifierOutput, loss, evalError, parameterLearners);

    int minibatchSize = 64;
    int numMinibatchesToTrain = 1000;

    // train the model
    for (int minibatchCount = 0; minibatchCount < numMinibatchesToTrain; minibatchCount++)
    {
        Value features, labels;
        GenerateValueData(minibatchSize, inputDim, numOutputClasses, out features, out labels, device);
        trainer.TrainMinibatch(
            new Dictionary<Variable, Value>() { { featureVariable, features }, { labelVariable, labels } }, device);
        TestHelper.PrintTrainingProgress(trainer, minibatchCount, 50);
    }

Dans ce code snip, un apprenant SGD intégré CNTK avec le taux d’apprentissage par échantillon = 0,02 est utilisé. L’apprenant est d’optimiser tous les paramètres du modèle. Un formateur est créé avec l’apprenant, une fonction de perte et une fonction d’évaluation. Pendant chaque minibatch d’itération d’entraînement, les données de minibatch sont transmises au formateur pour que les paramètres du modèle aient été mis à jour. L’erreur de perte et d’évaluation de Trainig s’affiche avec une méthode d’assistance pendant l’entraînement.
Dans le code, nous générons deux classes de données statistiquement séparables des étiquettes et des caractéristiques. Dans d’autres exemples plus réalistes, les données de test publiques sont chargées avec CNTK MinibatchSource.

Utilisation de l’API managée C#/.NET pour évaluer un réseau neuronal profond

L’API C# dispose de l’API d’évaluation pour effectuer l’évaluation du modèle. La plupart des exemples d’entraînement C# effectuent une évaluation de modèle après l’entraînement.

Vous trouverez plus de détails sur l’évaluation du modèle à l’aide de l’API CNTK C#

Prise en main des exemples de formation C#

Une fois que vous avez suivi cette vue d’ensemble, vous pouvez suivre des exemples de formation C# de deux façons : pour utiliser la source CNTK à partir de GitHub ou pour utiliser des exemples CNTK à l’aide de CNTK NuGet pour Windows.

utiliser la source CNTK

Suivez les étapes de cette page pour configurer CNTK sur windows.
Générez CNTK.sln avec Visual Studio.
Préparer des exemples de données.
Exécuter des exemples en tant que tests de bout en bout dans CNTKLibraryCSTrainingTest.csproj

utiliser des exemples CNTK avec CNTK NuGet

Télécharger des exemples de formation CNTK C#
Préparer des exemples de données.
Générez et exécutez les exemples.

Partager via