Uso di CNTK con L'API C#/.NET

Articolo
08/30/2017

CNTK v2.2.0 fornisce l'API C# per compilare, eseguire il training e valutare i modelli CNTK. Questa sezione offre una panoramica dell'API CNTK C#. Gli esempi di training C# sono disponibili nel repository GitHub CNTK.

Uso dell'API gestita C#/.NET per creare una rete neurale profonda

L'API CNTK C# fornisce operazioni di base nello spazio dei nomi CNTKLib. Un'operazione CNTK accetta una o due variabili di input con i parametri necessari e produce una funzione CNTK. Una funzione CNTK esegue il mapping dei dati di input all'output. Una funzione CNTK può anche essere considerata come variabile e può essere accettata come input per un'altra operazione CNTK. Con questo meccanismo, è possibile creare una rete neurale profonda con operazioni CNTK di base tramite concatenamento e composizione. Ad esempio:

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 sono operazioni CNTK di base. L'argomento di input può essere una variabile CNTK che rappresenta le funzionalità dei dati. Può anche trattarsi di un'altra funzione CNTK. Questo codice crea una rete di calcolo semplice con parametri regolati in fase di training per creare un classificatore multiclasse decente.

L'API CNTK C# fornisce operazioni per creare reti neurali di convoluzione (CNN) e reti neurali ricorrenti (RNN). Ad esempio, per creare un classificatore di immagini CNN a due livelli:

    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");

Viene fornito anche un esempio per la compilazione di un NNN con memoria a breve termine (LTSM).

Preparazione dei dati con C#/.NET

CNTK fornisce utilità di preparazione dei dati per il training. L'API CNTK C# espone queste utilità. Accetta i dati da vari moduli pre-elaborati. Il caricamento e l'invio in batch dei dati vengono eseguiti in modo efficiente. Si supponga, ad esempio, di avere dati nel testo nel formato di testo CNTK seguente denominato "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

Un'origine dati CNTK viene creata in questo modo:

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

I dati batch possono essere recuperati e usati per il training in un secondo momento:

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

Uso dell'API gestita C#/.NET per eseguire il training di una rete neurale profonda

La discesa del gradiente stocastico (SGD) è un modo per ottimizzare i parametri del modello con i dati di training minibatch. CNTK supporta molte varianti SGD comunemente viste nella letteratura di Deep Learning. Vengono esposti dall'API CNTK C#:

SGDLearner : uno learner SGD incorporato in CNTK
MomentumSGDLearner : uno sviluppatore di Momentum SGD incorporato in CNTK
FSAdaGradLearner - Variante dello learner AdaGrad
AdamLearner - uno learner Adam
AdaGradLearner - Strumento di apprendimento delle sfumature adattive
RMSPropLearner - strumento di apprendimento RMSProp
AdaDeltaLearner - learner AdaDelta

Per una panoramica generale dei diversi ottimizzatori di apprendimento, vedere Discesa del gradiente stocastico.

Un trainer CNTK viene usato per eseguire il training di minibatch. Snip del codice C# per il training di 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);
    }

In questo snip di codice viene usato un learner SGD predefinito CNTK con frequenza di apprendimento per campione = 0,02. Lo strumento di apprendimento consiste nell'ottimizzare tutti i parametri del modello. Viene creato un trainer con lo learner, una funzione di perdita e una funzione di valutazione. Durante ogni iterazione di training i dati di minibatch vengono inseriti nel formatore per aggiornare i parametri del modello. Durante il training vengono visualizzati errori di perdita e valutazione del training con un metodo helper.
Nel codice vengono generate due classi di dati statisticamente separabili di etichette e funzionalità. In altri esempi più realistici, i dati di test pubblici vengono caricati con CNTK MinibatchSource.

Uso dell'API gestita C#/.NET per valutare una rete neurale profonda

L'API C# ha l'API di valutazione per eseguire la valutazione del modello. La maggior parte degli esempi di training C# esegue la valutazione del modello dopo il training.

Altre informazioni sulla valutazione del modello con L'API CNTK C# sono disponibili all'indirizzo

Introduzione agli esempi di training C#

Dopo aver eseguito questa panoramica, è possibile procedere con gli esempi di training C# in due modi: usare l'origine CNTK da GitHub o usare esempi CNTK con CNTK NuGet per Windows.

usare l'origine CNTK

Seguire la procedura descritta in questa pagina per configurare CNTK in Windows.
Compilare CNTK.sln con Visual Studio.
Preparare i dati di esempio.
Eseguire esempi come test end-to-end in CNTKLibraryCSTrainingTest.csproj

Usare esempi CNTK con NuGet CNTK

Scaricare esempi di training CNTK C#
Preparare i dati di esempio.
Compilare ed eseguire gli esempi.

Condividi tramite