Dela via

Använda CNTK med C#/.NET API

  • Artikel

CNTK v2.2.0 tillhandahåller C#-API för att skapa, träna och utvärdera CNTK-modeller. Det här avsnittet innehåller en översikt över C#-API:et för CNTK. C#-träningsexempel är tillgängliga på CNTK github-lagringsplatsen.

Använda C#/.NET Managed API för att skapa ett djupt neuralt nätverk

C#-API:et CNTK tillhandahåller grundläggande åtgärder i CNTKLib-namnområdet. En CNTK-åtgärd tar en eller två indatavariabler med nödvändiga parametrar och skapar en CNTK-funktion. En CNTK-funktion mappar indata till utdata. En CNTK-funktion kan också behandlas som en variabel och tas som indata till en annan CNTK-åtgärd. Med den här mekanismen kan ett djupt neuralt nätverk skapas med grundläggande CNTK-åtgärder genom länkning och sammansättning. Som exempel:

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 är grundläggande CNTK-åtgärder. Indataargumentet kan vara en CNTK-variabel som representerar datafunktioner. Det kan också vara en annan CNTK-funktion. Den här koden skapar ett enkelt beräkningsnätverk med parametrar som justeras i träningsfasen för att göra en anständig flerklassificerare.

C#-API:et CNTK tillhandahåller åtgärder för att skapa neurala nätverk (CNN) och återkommande neurala nätverk (RNN). Om du till exempel vill skapa en CNN-bildklassificerare i två lager:

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

Ett exempel på hur du skapar ett RNN med long-short-term-memory (LTSM) finns också.

Förberedelse av data med C#/.NET

CNTK tillhandahåller verktyg för förberedelse av data för träning. CNTK C#-API:et exponerar dessa verktyg. Den tar data från olika förbearbetade formulär. Datainläsning och batchbearbetning görs effektivt. Anta till exempel att vi har data i text i följande CNTK-textformat med namnet "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

En CNTK-datakälla skapas på det här sättet:

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

Batchdata kan hämtas och användas för träning senare:

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

Använda C#/.NET Managed API för att träna ett djupt neuralt nätverk

SGD (Stochastic Gradient Descent) är ett sätt att optimera modellparametrar med minibatch-träningsdata. CNTK stöder många SGD-varianter som ofta ses i djupinlärningslitteraturen. De exponeras av C#-API:et för CNTK:

  • SGDLearner – en inbyggd CNTK-SGD-deltagare
  • MomentumSGDLearner – en inbyggd Momentum SGD-deltagare i CNTK
  • FSAdaGradLearner – en variant av AdaGrad-elever
  • AdamLearner - en Adam learner
  • AdaGradLearner – en adaptiv gradient learner
  • RMSPropLearner – en RMSProp-inläsare
  • AdaDeltaLearner – en AdaDelta-deltagare

En allmän översikt över olika inlärningsoptimerare finns i Stochastic gradient descent (Stochastic gradient descent).

En CNTK-tränare används för att göra minibatchträning. Ett C#-kodstycke för minibatchträning:

    // 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);
    }

I det här kodfragmentet används en inbyggd CNTK-SGD-learner med per exempelinlärningsfrekvens = 0,02. Den som lär sig är att optimera alla parametrar i modellen. En tränare skapas med eleven, en förlustfunktion och en utvärderingsfunktion. Under varje träningsiteration matas minibatch-data till tränaren för att modellparametrarna ska uppdateras. Träningsförlust- och utvärderingsfel visas med en hjälpmetod under träningen.
I koden genererar vi två klasser med statistiskt särskiljbara data för etiketter och funktioner. I andra mer realistiska exempel läses offentliga testdata in med CNTK MinibatchSource.

Använda C#/.NET Managed API för att utvärdera ett djupt neuralt nätverk

C#-API:et har utvärderings-API:et för modellutvärdering. De flesta C#-träningsexempel utför modellutvärdering efter träning.

Mer information om modellutvärdering med CNTK C#-API finns på

Kom igång med C#-träningsexempel

När du har gått igenom den här översikten kan du fortsätta med C#-utbildningsexempel på två sätt: att arbeta med CNTK-källa från GitHub eller att arbeta med CNTK-exempel med CNTK NuGet för Windows.

arbeta med CNTK-källa

  • Följ stegen på den här sidan om du vill konfigurera CNTK på windows.
  • Skapa CNTK.sln med Visual Studio.
  • Förbereda exempeldata.
  • Köra exempel som slutpunkt till slutpunkt-tester i CNTKLibraryCSTrainingTest.csproj

arbeta med CNTK-exempel med CNTK NuGet