In depth LSTM Implementation using CNTK on .NET platform

In this blog post the implementation of the LSTM recurrent neural network in CNTK will be shown in detail. The implementation will cover LSTM implementation based on Hochreiter & Schmidhuber (1997) paper which can be found here here. The great blog post about LSTM can also be found at colah’s blog, that explains in details the structure of the LSTM cell, as well as some of the most used LSTM variants. In this blog post the LSTM recurrent network will be implemented using CNTK, a deep learning tool using C# programming language and .NET Core platform. Also in case you want to see how to use pure C# without any additional library for LSTM implementation, you can see great MSDN article: Test Run – Understanding LSTM Cells Using C# By James McCaffrey.

Whole implementation of LSTM RNN is part of ANNdotNET – deep learning tool on .NET platform. More information about the project can be found at GitHub Project page:

Introduction to LSTM Recurrent Network

Classic neural networks are built on the fact that data don’t have any order when entering into the network, and the output depend only on the input features. In case when the output depends on features and previous outputs, the classic feed forward neural network cannot help. The solution for such problem may be neural network which can be recursively provides the previous outputs. This kind of network is called recurrent neural network RNN, and it was introduced by the Hopfields in the 1980s, and later popularized when the back-propagation algorithm was improved in the beginning of 1990s. Simple concept of the recurrent neural network can be shown on the following image.

The current output of the recurrent network is defined by the current input Xt, and also on states related on the previous network outputs ht-1, ht-2,

The concept of the recurrent neural network is simple and easy to implement, but the problem raises during the training phase due to unpredictable gradient behavior. During training phase, gradient problem of neural network can be summarized in two categories: the vanishing and the exploding gradient.

The recurrent neural network is based on back-propagation algorithm, specially developed for the recurrent ANN, which is called back-propagation through time, BPTT.  In vanishing gradient problem parameters updates are proportional to the gradient of the error, which in most cases negligibly small, and results that the corresponding weights are constant and stop the network from further training.

On the other hand, exploding gradient problem refers to the opposite behavior, where the updates of weights (gradient of the cost function) became large in each back-propagation step. This problem is caused by the explosion of the long-term components in the recurrent neural network.

The solution to the above problems is specific design of there current network called Long Short-Term Memory, LSTM. One of the main advantages of the LSTM is that it can provide a constant error flow. In order to provide a constant error flow, the LSTM cell contains set of memory blocks,which have the ability to store the temporal state of the network. The LSTM also has special multiplicative units called gates that control the information flow.

The LSTM cell consists of:

  • input gate – which controls the flow of the input activations into the memory cell,
  • output gate which controls the output flow of the cell activation.
  • forget gate, which filters the information from the input and previous output and decides which one should be remembered or forgot and dropped out.

Besides three gates the LSTM cell contains cell update which is usually tanh layer to be part of the cell state.

In each LSTM cell the three variables are coming into the cell:

  • the current input xt,
  • previous output ht-1 and
  • previous cell state ct-1.

On the other hand, from each LSTM cell two variables are getting out:

  • the current output ht and
  • the current cell state ct.

Graphical representation of the LSTM cell is shown on the following image.

In order to implement LSTM recurrent network, first the LSTM cell should be implemented. The LSTM cell has three gates, and two internal states, which should be determined in order to calculate the current output and current cell state.

The LSTM cell can be define as neural network where the input vector x=\left(x_1,x_2,x_3,\ldots x_t\right)  in time t, maps to the output vector y=\left(y_1,\ y_2,\ \ldots,y_m\right), through the calculation of the following layers:

  • the forget gate sigmoid layer for the time t, ft  is calculated by the previous output ht-1 the input vector xt, and the matrix of weights from the forget layer Wf with addition of corresponded bias bi:


  • the input gate sigmoid layer for the time t, it  is calculated by the previous output ht-1 the input vector xt, and the matrix of weights from the input layer Wi with addition of corresponded bias bi:


  • the cell state in time t, Ct  is calculated from the forget gate 
    ft  and the previous cell state Ct-1. The result is summed wth the input gate it and the cell update state {\widetilde{c}}_t, that is tanh layer calculated by the previous output ht-1 the input vector xt, and the weight matrix for the cell with addition of corresponded bias bi:

C_t=f_t\ \otimes C_{t-1}+\ i_t\otimes\tanh{\left(\ W_C\bullet\left[h_{t-1},x_t\right]+b_C\right).}

  • the output gate sigmoid layer for the time t, ot is calculated by the previous output ht-1, the input vector xt, and the matrix of weights from the output layer Wo with addition of corresponded bias bi:

o_t=\sigma\left(\ W_0\bullet\left[h_{t-1},x_t\right]+b_0\right).

The final stage of the LSTM cell is current output ht calculation. The current output  is calculated with the multiplication operation \otimes between output gate layer and tanh layer of the current cell state Ct .


The current output ht, has passed through the network as the previous state for the next LSTM cell, or as the input for neural network output layer.

LSTM with Peephole connection

One of the LSTM variant which is implemented in python based CNTK is LSTM with peephole connection which is first introduced by Gers & Schmidhuber (2000). LSTM with peephole connection let each gate (forget, input and output) look at the cell state.

Now the gates with peephole connection can be expressed sothat the started terms of each gates are extended with additional matrix of Ct.So, the forget gate with peephole can be expressed:

f_t=\sigma\left(W_f\bullet\left[{C_{t-1},\ h}_{t-1},x_t\right]+b_f\right).

Similarly, the input gate and the output gate with peephole connection are expressed as:

i_t=\sigma\left(W_i\bullet\left[C_{t-1},\ h_{t-1},x_t\right]+b_i\right),

o_t=\sigma\left(\ W_0\bullet\left[{C_{t-1},h}_{t-1},x_t\right]+b_0\right).

With peephole connection LSTM cell get additional matrix for each gate and the number of LSTM parameters are increased by additional 3mXm parameters, where m – is output dimension.

Implementation of LSTM Recurrent network

The CNTK is Microsoft open source library for deep learning written in C++, but it can be run from various programming languages: Python,C#, R, Java. In order to use the library in C#, the CNTK related Nugget package has to be installed, and the project must be built for 64bit architecture.

  1. So open Visual Studio 2017 and create simple .NET Core Console application.
  2. Then install CNTK GPU Nugget package to your recently created console application.

Once the startup project is created the LSTM CNTK implementation can be started.

Implementation of the LSTM Cell

As stated previously the implementation presented in this blog post is  originally implemented in ANNdotNET – open source project for deep learning on .NET platform. It can be found at official GitHub project page

The LSTM recurrent network starts by implementation of the LSTMCell class. The LSTMCell class is derived from the NetworkFoundation class which implements basic neural network operations. The Basic operations are implemented through the implementation of the following methods:

  • Bias – bias parameters implementation
  • Weights – implementation of the weights parameters
  • Layer – implementation of the classic fully connected linear layer
  • AFunction – applying activation function on the layer.

NetworkFoundation class is shown in the next code snippet

// ANNdotNET - Deep Learning Tool on .NET Platform                                                      
// Copyright 2017-2018 Bahrudin Hrnjica                                                                                                                                       //
// This code is free software under the MIT License                                     //
// See license section of  //
// Bahrudin Hrnjica                                                                     
// Bihac, Bosnia and Herzegovina                                                         //
using CNTK;
using NNetwork.Core.Common;

namespace NNetwork.Core.Network
public class NetworkFoundation

public Variable Layer(Variable x, int outDim, DataType dataType, DeviceDescriptor device, uint seed = 1 , string name="")
    var b = Bias(outDim, dataType, device);         
    var W = Weights(outDim, dataType, device, seed, name);

    var Wx = CNTKLib.Times(W, x, name+"_wx");
    var l = CNTKLib.Plus(b,Wx, name);

    return l;

public Parameter Bias(int nDimension, DataType dataType, DeviceDescriptor device)
    //initial value
    var initValue = 0.01;
    NDShape shape = new int[] { nDimension };
    var b = new Parameter(shape, dataType, initValue, device, "_b");
    return b;

public Parameter Weights(int nDimension, DataType dataType, DeviceDescriptor device, uint seed = 1, string name = "")
    //initializer of parameter
    var glorotI = CNTKLib.GlorotUniformInitializer(1.0, 1, 0, seed);
    //create shape the dimension is partially known
    NDShape shape = new int[] { nDimension, NDShape.InferredDimension };
    var w = new Parameter(shape, dataType, glorotI, device, name=="" ? "_w" : name);
    return w;

public Function AFunction(Variable x, Activation activation, string outputName="")
    switch (activation)
        case Activation.None:
            return x;
        case Activation.ReLU:
            return CNTKLib.ReLU(x, outputName);
        case Activation.Softmax:
            return CNTKLib.Sigmoid(x, outputName);
        case Activation.Tanh:
            return CNTKLib.Tanh(x, outputName);

As can be seen, methods implement basic neural buildingblocks, which can be apply to any network type. Once the NetworkFoundation baseclass is implemented, the LSTM cell class implementation starts by definingthree properties and custom constructor, that is shown in the following code snippet:

// ANNdotNET - Deep Learning Tool on .NET Platform                                                       
// Copyright 2017-2018 Bahrudin Hrnjica                                                                                                                                       //
// This code is free software under the MIT License                                     //
// See license section of  //
// Bahrudin Hrnjica                                                                     
// Bihac, Bosnia and Herzegovina                                                         //
using CNTK;
using NNetwork.Core.Common;

namespace NNetwork.Core.Network.Modules
public class LSTM : NetworkFoundation
    public Variable X { get; set; } //LSTM Cell Input
    public Function H { get; set; } //LSTM Cell Output
    public Function C { get; set; } //LSTM Cell State

public LSTM(Variable input, Variable dh, Variable dc, DataType dataType, Activation actFun, bool usePeephole, bool useStabilizer, uint seed, DeviceDescriptor device)
    //create cell state
    var c = CellState(input, dh, dc, dataType, actFun, usePeephole, useStabilizer, device, ref seed);

    //create output from input and cell state
    var h = CellOutput(input, dh, c, dataType, device, useStabilizer, usePeephole, actFun, ref seed);

    //initialize properties
    X = input;
    H = h;
    C = c;

Properties X, H and C, hold current values of the LSTM cell,once the LSTM object is created. The LSTM constructor takes several arguments:

  • the first three are variables for the input, previous output and previous cell state;
  • the activation function of the cell update layer. 

The constructor also contains two arguments for creation a different LSTM variant: peepholes, and self-stabilization, and few other self-explained arguments. The LSTM constructor creates cell state and output by calling CellState and CellOutput methods respectively. Thei mplementation of those methods is shown on the next code snippet:

public Function CellState(Variable x, Variable ht_1, Variable ct_1, DataType dataType, 
    Activation activationFun, bool usePeephole, bool useStabilizer, DeviceDescriptor device, ref uint seed)
    var ft = AGate(x, ht_1, ct_1, dataType, usePeephole, useStabilizer, device, ref seed, "ForgetGate");
    var it = AGate(x, ht_1, ct_1, dataType, usePeephole, useStabilizer, device, ref seed, "InputGate");
    var tan = Gate(x, ht_1, ct_1.Shape[0], dataType, device, ref seed);

    //apply Tanh (or other) to gate
    var tanH = AFunction(tan, activationFun, "TanHCt_1" );

    //calculate cell state
    var bft = CNTKLib.ElementTimes(ft, ct_1,"ftct_1");
    var bit = CNTKLib.ElementTimes(it, tanH, "ittanH");

    //cell state
    var ct = CNTKLib.Plus(bft, bit, "CellState");
    return ct;

public Function CellOutput(Variable input, Variable ht_1, Variable ct, DataType dataType, DeviceDescriptor device, 
    bool useStabilizer, bool usePeephole, Activation actFun ,ref uint seed)
    var ot = AGate(input, ht_1, ct, dataType, usePeephole, useStabilizer, device, ref seed, "OutputGate");

    //apply activation function to cell state
    var tanHCt = AFunction(ct, actFun, "TanHCt");

    //calculate output
    var ht = CNTKLib.ElementTimes(ot, tanHCt,"Output");

    //create output layer in case different dimensions between cell and output
    var c = ct;
    Function h = null;
    if (ht.Shape[0] != ct.Shape[0])
        //rectified dimensions by adding linear layer
        var so = !useStabilizer? ct : Stabilizer(ct, device);
        var wx_b = Weights(ht_1.Shape[0], dataType, device, seed++);
        h = wx_b * so;
        h = ht;

    return h;

Above methods have been implemented by using previously defined gates and blocks. The method AGate creates LSTM gate. The method is called two times in order to create forget and input gates. Then the Gate method is called in order to create linear layer for the update cell state. The activation function is provided as the constructor argument. Implementation of AGate and Gate functions is shown in the following code snippet:

public Variable AGate(Variable x, Variable ht_1, Variable ct_1, DataType dataType, bool usePeephole,
    bool useStabilizer, DeviceDescriptor device, ref uint seed, string name)
    //cell dimension
    int cellDim = ct_1.Shape[0];
    //define previous output with stabilization of if defined
    var h_prev = !useStabilizer ? ht_1 : Stabilizer(ht_1, device);

    //create linear gate
    var gate = Gate(x, h_prev, cellDim, dataType, device, ref seed);
    if (usePeephole)
        var c_prev = !useStabilizer ? ct_1 : Stabilizer(ct_1, device);
        gate = gate + Peep(c_prev, dataType, device, ref seed);
    //create forget gate
    var sgate = CNTKLib.Sigmoid(gate, name);
    return sgate;

private Variable Gate(Variable x, Variable hPrev, int cellDim,
                            DataType dataType, DeviceDescriptor device, ref uint seed)
    //create linear layer
    var xw_b = Layer(x, cellDim, dataType, device, seed++);
    var u = Weights(cellDim, dataType, device, seed++,"_u");
    var gate = xw_b + (u * hPrev);
    return gate;

As can be seen AGate calls the Gate method in order to create linear layer, and then apply the activation function.

In order to create LSTM variant with peephole connection, as well as LSTM with self-stabilization, two additional methods are implemented. The peephole connection is explained previously. The implementation of Stabilizer methods is based on the implementation found at C# examples on the CNTK github page, with minor modification and re-factorization.

internal Variable Stabilizer(Variable x, DeviceDescriptor device)
    //define floating number
    var f = Constant.Scalar(4.0f, device);

    //make inversion of prev. value
    var fInv = Constant.Scalar(f.DataType, 1.0 / 4.0f);

    //create value of 1/f*ln (e^f-1)
    double initValue = 0.99537863;

    //create param with initial value
    var param = new Parameter(new NDShape(), f.DataType, initValue, device, "_stabilize");

    //make exp of product scalar and parameter
    var expValue = CNTKLib.Exp(CNTKLib.ElementTimes(f, param));

    var cost = Constant.Scalar(f.DataType, 1.0) + expValue;

    var log = CNTKLib.Log(cost);

    var beta = CNTKLib.ElementTimes(fInv, log);

    //multiplication of the variable layer with constant scalar beta
    var finalValue = CNTKLib.ElementTimes(beta, x);

    return finalValue;

internal Function Peep(Variable cstate, DataType dataType, DeviceDescriptor device, ref uint seed)
    //initial value
    var initValue = CNTKLib.GlorotUniformInitializer(1.0, 1, 0, seed);

    //create shape which for bias should be 1xn
    NDShape shape = new int[] { cstate.Shape[0] };

    var bf = new Parameter(shape, dataType, initValue, device, "_peep");

    var peep = CNTKLib.ElementTimes(bf, cstate);
    return peep;

The Peep method is based on previous description in the blog post, that simply adds the additional set of parameters which includes the previous cell state into Gates.

Implementation of the LSTM Recurrent Network

Once we have the LSTM cell implementation it is easy toimplement recurrent network based on LSTM. Previously the LSTM is defined withthree input variables: input and two previous state variables. Those previous states should be defined not as real variables but as placeholders, and should be changed dynamically for each iteration. So, the recurrent network starts by defining placeholders of previous output and previous cell state. Then the LSTMcell object is created. Once the the LSTM is created, the actual values is replaced by the previous values by calling the CNTK method PastValue. Then the placeholders are replaced with the past values of the variables. At the end the method return the CNTK Function object, which can be one of two cases, which is controlled by the returnSequence argument:

  • first case where the method returns the full sequence,
  • second case where the methods return the last element of the sequence.
// ANNdotNET - Deep Learning Tool on .NET Platform                                      
// Copyright 2017-2018 Bahrudin Hrnjica                                                 
// This code is free software under the MIT License                                     
// See license section of  
// Bahrudin Hrnjica                                                                     
// Bihac, Bosnia and Herzegovina                                                         
//                                                                  //
using CNTK;
using NNetwork.Core.Common;
using NNetwork.Core.Network.Modules;
using System;
using System.Collections.Generic;

namespace NNetwork.Core.Network
public class RNN
public static Function RecurrenceLSTM(Variable input, int outputDim, int cellDim, DataType dataType, DeviceDescriptor device, bool returnSequence=false,
    Activation actFun = Activation.TanH, bool usePeephole = true, bool useStabilizer = true, uint seed = 1)
    if (outputDim <= 0 || cellDim <= 0)
        throw new Exception("Dimension of LSTM cell cannot be zero.");
    //prepare output and cell dimensions 
    NDShape hShape = new int[] { outputDim };
    NDShape cShape = new int[] { cellDim };

    //create placeholders
    //Define previous output and previous cell state as placeholder which will be replace with past values later
    var dh = Variable.PlaceholderVariable(hShape, input.DynamicAxes);
    var dc = Variable.PlaceholderVariable(cShape, input.DynamicAxes);

    //create lstm cell
    var lstmCell = new LSTM(input, dh, dc, dataType, actFun, usePeephole, useStabilizer, seed, device);

    //get actual values of output and cell state
    var actualDh = CNTKLib.PastValue(lstmCell.H);
    var actualDc = CNTKLib.PastValue(lstmCell.C);

    // Form the recurrence loop by replacing the dh and dc placeholders with the actualDh and actualDc
    lstmCell.H.ReplacePlaceholders(new Dictionary<Variable, Variable> { { dh, actualDh }, { dc, actualDc } });

    //return value depending of type of LSTM layer
    if (returnSequence)
        return lstmCell.H;
        return CNTKLib.SequenceLast(lstmCell.H); 


As can be seen, the RNN class contains only one static method, which return the CNTK Function object which contains the recurrent network with LSTM cell. The method takes several arguments: input variable, dimension of the output of the recurrent network, dimension of the LSTM cell, and the additional arguments for creation different variants of the LSTM cell.

Implementation of Test Application

Now that the full LSTM based recurrent network is implemented, we are going to provide the test application that can test basic LSTM functionality. The application contains two test methods in order to check:

  • number of LSTM parameters, and
  • output and cell states of the LSTM cell for two iterations.

Testing the correct number of the parameters

The first method implements validation of the correct numberof LSTM parameters. The LSTM cell has three kinds of matrices: U and W and bfor each LSTM component: forget, input and output gate, and cell update.
Let assume the number of input dimension is n,and the number of output is m. Also let assume that dimension number of the cell is equal to output dimension. We can defined the following matrices:

  • U matrix with dimensions of mxn
  • W matrix with dimensions of mxm
  • B matrix (vector) with dimensions 1xm

In total the LSTM has P_{\left(LSTM\right)}=4\bullet\left(m^2+m\bullet n+m\right).

In case the LSTM has peephole connection the the number of parameters is increased with additional C matrix with 1xm parameters.

In total the LSTM with peephole connection has P_{\left(LSTM\right)}=4\bullet\left(m^2+m\bullet n+m\right)+3\bullet1\bullet m. The test method is implemented for n=3, and m=4, so the total number of parameters for default LSTM cell is P(n)=4(9+6+3)=4*18=72. With peephole connection the LSTM cell has P(n)= 4(9+6+3)+3*1*4 = 4*18+3*16 = 72+12=84.

In case the LSTM cell is defined with self-stabilization parameter, the additional 4xm parameters are defined.

Now that we defined parameter number for pure LSTM, with peephole and self-stabilization, we can implement test methods based on n=3 and m=4:

public void LSTM_Test_Params_Count()
    //define values, and variables
    Variable x = Variable.InputVariable(new int[] { 3 }, DataType.Float, "input");
    Variable y = Variable.InputVariable(new int[] { 4 }, DataType.Float, "output");

    //Number of LSTM parameters
    var lstm1 = RNN.RecurrenceLSTM(x,4,4, DataType.Float,device, Activation.Tanh,true,true,1);

    var ft = lstm1.Inputs.Where(l=>l.Uid.StartsWith("Parameter")).ToList();
    var consts = lstm1.Inputs.Where(l => l.Uid.StartsWith("Constant")).ToList();
    var inp = lstm1.Inputs.Where(l => l.Uid.StartsWith("Input")).ToList();

    //bias params
    var bs = ft.Where(p=>p.Name.Contains("_b")).ToList();
    var totalBs = bs.Sum(v => v.Shape.TotalSize);
    var ws = ft.Where(p => p.Name.Contains("_w")).ToList();
    var totalWs = ws.Sum(v => v.Shape.TotalSize);
    Assert.AreEqual(totalWs, 24);
    var us = ft.Where(p => p.Name.Contains("_u")).ToList();
    var totalUs = us.Sum(v => v.Shape.TotalSize);
    Assert.AreEqual(totalUs, 36);

    var totalOnly = totalBs + totalWs + totalUs;
    var totalWithSTabilize = totalOnly + totalst;
    var totalWithPeep = totalOnly + totalPh;

    var totalP = totalOnly + totalst + totalPh;
    var totalParams = ft.Sum(v=>v.Shape.TotalSize);

Testing the output and cell state values

In this test the network parameters input, previous output and cell states are setup. The result of this test is weather the LSTM cell returns correct output and cell state values for first and second iteration. The implementation of this test is shows on the following code snippet:

public void LSTM_Test_WeightsValues()

    //define values, and variables
    Variable x = Variable.InputVariable(new int[] { 2 }, DataType.Float, "input");
    Variable y = Variable.InputVariable(new int[] { 3 }, DataType.Float, "output");

    //data 01
    var x1Values = Value.CreateBatch<float>(new NDShape(1, 2), new float[] { 1f, 2f }, device);
    var ct_1Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { 0f, 0f, 0f }, device);
    var ht_1Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { 0f, 0f, 0f }, device);

    var y1Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { 0.0629f, 0.0878f, 0.1143f }, device);

    //data 02
    var x2Values = Value.CreateBatch<float>(new NDShape(1, 2), new float[] { 3f, 4f }, device);
    var y2Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { 0.1282f, 0.2066f, 0.2883f }, device);

    //Create LSTM Cell with predefined previous output and prev cell state
    Variable ht_1 = Variable.InputVariable(new int[] { 3 }, DataType.Float, "prevOutput");
    Variable ct_1 = Variable.InputVariable(new int[] { 3 }, DataType.Float, "prevCellState");
    var lstmCell = new LSTM(x, ht_1, ct_1, DataType.Float, Activation.Tanh, false, false, 1, device);

    var ft = lstmCell.H.Inputs.Where(l => l.Uid.StartsWith("Parameter")).ToList();
    var pCount = ft.Sum(p => p.Shape.TotalSize);
    var consts = lstmCell.H.Inputs.Where(l => l.Uid.StartsWith("Constant")).ToList();
    var inp = lstmCell.H.Inputs.Where(l => l.Uid.StartsWith("Input")).ToList();

    //bias params
    var bs = ft.Where(p => p.Name.Contains("_b")).ToList();
    var pa = new Parameter(bs[0]);
    pa.SetValue(new NDArrayView(pa.Shape, new float[] { 0.16f, 0.17f, 0.18f }, device));
    var pa1 = new Parameter(bs[1]);
    pa1.SetValue(new NDArrayView(pa1.Shape, new float[] { 0.16f, 0.17f, 0.18f }, device));
    var pa2 = new Parameter(bs[2]);
    pa2.SetValue(new NDArrayView(pa2.Shape, new float[] { 0.16f, 0.17f, 0.18f }, device));
    var pa3 = new Parameter(bs[3]);
    pa3.SetValue(new NDArrayView(pa3.Shape, new float[] { 0.16f, 0.17f, 0.18f }, device));
    //set value to weights parameters
    var ws = ft.Where(p => p.Name.Contains("_w")).ToList();
    var ws0 = new Parameter(ws[0]);
    var ws1 = new Parameter(ws[1]);
    var ws2 = new Parameter(ws[2]);
    var ws3 = new Parameter(ws[3]);
    (ws0).SetValue(new NDArrayView(ws0.Shape, new float[] { 0.01f, 0.03f, 0.05f, 0.02f, 0.04f, 0.06f }, device));
    (ws1).SetValue(new NDArrayView(ws1.Shape, new float[] { 0.01f, 0.03f, 0.05f, 0.02f, 0.04f, 0.06f }, device));
    (ws2).SetValue(new NDArrayView(ws2.Shape, new float[] { 0.01f, 0.03f, 0.05f, 0.02f, 0.04f, 0.06f }, device));
    (ws3).SetValue(new NDArrayView(ws3.Shape, new float[] { 0.01f, 0.03f, 0.05f, 0.02f, 0.04f, 0.06f }, device));
    //set value to update parameters
    var us = ft.Where(p => p.Name.Contains("_u")).ToList();
    var us0 = new Parameter(us[0]);
    var us1 = new Parameter(us[1]);
    var us2 = new Parameter(us[2]);
    var us3 = new Parameter(us[3]);
    (us0).SetValue(new NDArrayView(us0.Shape, new float[] {  0.07f, 0.10f, 0.13f, 0.08f, 0.11f, 0.14f, 0.09f, 0.12f, 0.15f }, device));
    (us1).SetValue(new NDArrayView(us1.Shape, new float[] {  0.07f, 0.10f, 0.13f, 0.08f, 0.11f, 0.14f, 0.09f, 0.12f, 0.15f }, device));
    (us2).SetValue(new NDArrayView(us2.Shape, new float[] {  0.07f, 0.10f, 0.13f, 0.08f, 0.11f, 0.14f, 0.09f, 0.12f, 0.15f }, device));
    (us3).SetValue(new NDArrayView(us3.Shape, new float[] {  0.07f, 0.10f, 0.13f, 0.08f, 0.11f, 0.14f, 0.09f, 0.12f, 0.15f }, device));

    //Evaluate model after weights are setup
    var inV = new Dictionary<Variable, Value>();
    inV.Add(x, x1Values);
    inV.Add(ht_1, ht_1Values);
    inV.Add(ct_1, ct_1Values);

    //evaluate output when previous values are zero
    var outV11 = new Dictionary<Variable, Value>();
    outV11.Add(lstmCell.H, null);
    lstmCell.H.Evaluate(inV, outV11, device);
    //test  result values
    var result = outV11[lstmCell.H].GetDenseData<float>(lstmCell.H);
    Assert.AreEqual(result[0][0], 0.06286034f);//
    Assert.AreEqual(result[0][1], 0.0878196657f);//
    Assert.AreEqual(result[0][2], 0.114274308f);//

    //evaluate cell state
    var outV = new Dictionary<Variable, Value>();
    outV.Add(lstmCell.C, null);
    lstmCell.C.Evaluate(inV, outV, device);

    var resultc = outV[lstmCell.C].GetDenseData<float>(lstmCell.C);
    Assert.AreEqual(resultc[0][0], 0.114309229f);//
    Assert.AreEqual(resultc[0][1], 0.15543206f);//
    Assert.AreEqual(resultc[0][2], 0.197323829f);//

    //evaluate second value, with previous values as previous state
    //setup previous state and output
    ct_1Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { resultc[0][0], resultc[0][1], resultc[0][2] }, device);
    ht_1Values = Value.CreateBatch<float>(new NDShape(1, 3), new float[] { result[0][0], result[0][1], result[0][2] }, device);

    //Prepare for the evaluation
    inV = new Dictionary<Variable, Value>();
    inV.Add(x, x2Values);
    inV.Add(ht_1, ht_1Values);
    inV.Add(ct_1, ct_1Values);

    outV11 = new Dictionary<Variable, Value>();
    outV11.Add(lstmCell.H, null);
    lstmCell.H.Evaluate(inV, outV11, device);

    //test  result values
    result = outV11[lstmCell.H].GetDenseData<float>(lstmCell.H);
    Assert.AreEqual(result[0][0], 0.128203377f);//
    Assert.AreEqual(result[0][1], 0.206633776f);//
    Assert.AreEqual(result[0][2], 0.288335562f);//

    //evaluate cell state
    outV = new Dictionary<Variable, Value>();
    outV.Add(lstmCell.C, null);
    lstmCell.C.Evaluate(inV, outV, device);

    //evaluate cell state with previous value
    resultc = outV[lstmCell.C].GetDenseData<float>(lstmCell.C);
    Assert.AreEqual(resultc[0][0], 0.227831185f);//
    Assert.AreEqual(resultc[0][1], 0.3523231f);//
    Assert.AreEqual(resultc[0][2], 0.4789199f);//

In this article the implementation of the LSTM cell is presented in details from the theory and implementation. Also the article contains two test methods in order to prove the correctness of the implementation. The result values of the output and the cell states are compared with manually calculated values.

Create CIFAR-10 Deep Learning Model With ANNdotNET GUI Tool

With ANNdotNET 1.2 the user is able to create and train deep learning models for image classification. Image classification module provides minimum of GUI actions in order to fully prepare data set. In this post, we are going to create and train deep learning model for CIFAR-10 data set, and see how it easy to do that with ANNdotNET v1.2.

In order to prepare data we have to download CIFAR-10 data set from official web site . The CIFAR-10 data set is provided in 6 binary batch files that should be extracted and persisted on your local machine. Number 10 in the name means that data set is created for 10 labels.The following image shows 10 labels of CIFAR-10 data set each label with few sample images.

CIFAR-10 data set (Learning Multiple Layers of Features from Tiny Images, Alex Krizhevsky, 2009.)

The data set contains 60 000 (50 000 for training and validation, and 10 000 for test) tinny colored images dimensions of 32×32. There is also bigger version of the data set CIFAR-100 with 100 labels. Our task is to create deep learning model capable of recognizing only one of 10 predefined labels from each image.

Data preparation

In order to prepare images, we need to do the following:

The following image shows extracted data set persisted in 10 label folders. The bird folder is opened and shows all images labeled for bird. The test folder contains all images created for testing the model once the model is trained.

In order to properly save all images, we need to create simple C# Console application which should extract and save all 60 000 images. Complete C# program can be downloaded from here.

In order to successfully extract the images, we have to see how those images are stored in binary files. From the official site we can see that there are 5 for training and 1 for test binary files: data_batch_1.bin, data_batch_2.bin, …, data_batch_5.bin, as well as test_batch.bin.

Each of these files is formatted as follows so that the first byte of the array is label index, and the next 3072 bytes represent the image. Each batch contains 10 000 images.

Important to know is that images are stored in CHW format which means that 1d image array is created so that the first 1024 bytes are the red channel values, the next 1024 the green, and the final 1024 the blue. The values are stored in row-major order, so the first 32 bytes are the red channel values of the first row of the image. To end this, all those information have been carried out when implementing the Extractor application. The most important methods are reshaping the 1D byte array into [3, height, width] image tensor, and creating the image from the byte tensor. The following implementation shows how 1D byte array is transformed into 3channel bitmap tensor.

static int[][][] reshape(int channel, int height, int width,  byte[] img)
    var data = new int[channel][][];
    int counter = 0;
    for(int c = 0; c < channel; c++)
        data[c] = new int[height][];
        for (int y = 0; y < height; y++)
            data[c][y] = new int[width];
            for (int x = 0; x < width; x++)
                data[c][y][x] = img[counter];
    return data;

Once the 1D byte array is transformed into tensor, the image can be created and persisted on disk. The following method iterates through all 10000 images in one batch file, extract them and persist on disk.

public static void extractandSave(byte[] batch, string destImgFolder, ref int imgCounter)
    var nStep = 3073;//1 for label and 3072 for image
    for (int i = 0; i < batch.Length; i += nStep)
        var l = (int)batch[i];
        var img = new ArraySegment<byte>(batch, i + 1, nStep - 1).ToArray();
// data in CIFAR-10 dataset is in CHW format, which means CHW: RR...R, GG..G, BB..B;

        // while HWC: RGB, RGB, ... RGB
        var reshaped = reshape(3, 32, 32, img);
        var image = ArrayToImg(reshaped);
        //check if folder exist
        var currentFolder = destImgFolder + classNames[l];

        if (!Directory.Exists(currentFolder))

        //save image to specified folder
        image.Save(currentFolder + "\\" + imgCounter.ToString() + ".png");


Run Cifar-Extractor console application and the process of downloading, extracting and saving images will be finished in few minutes. The most important is that CIFAR-10 data set will be stored in c://sc/datasets/cifar-10 path. This is important later, when we create image classifier.

Now that we have 60000 tiny images on disk arranged by labels we can start creating deep learning model.

Create new image classification project file in ANNdotNET

Open the latest ANNdotNET v1.2 and select New-> Image Classification project. Enter CIFAR project name and press save button. The following image shows CIFAR new ann-project:

Once we have new project, we can start defining image labels by pressing Add button. For each 10 labels we need to add new label item in the list. In each item the following fields should be defined:

  • Image label
  • Path to images with the label.
  • Query – in case we need to get all images within the specified path with certain part of the name. In case all images withing the specified path are images that indicate one label, query should be empty string.

Beside Label item, image transformation should be defined in order to define the size of the images, as well as how many images create validation/test data set.

Assuming the CIFAR-10 data set is extracted at c:/sc/datasets/cifar-10 folder, the following image shows how label items should be defined:

In case label item should be removed from the list, this is done by selecting the item, and then pressing Remove button. Beside image properties, we should defined how many images belong to validation data set. As can be seen 20% of all extracted images will be created validation data set. Notice that images from the test folder are not part of those two data set. they will be used for testing phase once the model is trained. Now that we done with data preparation we can move to the next step: creating mlconifg file.

Create mlconfig in ANNdotNET

By selecting New MLConfig command the new mlconfig file is created within the project explorer. Moreover by pressing F2 key on selected mlconfig tree item, we can easily change the name into “CIRAF-10-ConvNet”. The reason why we gave such name is because we are going to use convolution neural networks.

In order to define mlconfig file we need to define the following:

  • Network configuration using Visual Network Designer
  • Define Learning parameters
  • Define training parameters

Create Network configuration

By using Visual Network Designer (VND) we can quickly create network model. For this CIFAR-10 data set we are going to create 11 layers model with 4 Constitutional, 2 Pooling, 1 DropOut and 3 Dense layer, all followed by Scale layer:

Scale (1/255)->Conv2D(32,[3,3])->Conv2D(32,[3,3])->Pooling2d([2,2],2)->Conv2D(64,[3,3])->Conv2D(64,[3,3])->Pooling2d([2,2],2)->DropOut(0.5)->Dense(64, TanH)->Dense(32, TanH)->Dense(10,Softmax)

This network can be created so that we select appropriate layer from the VND combo box and click on Add button. The first layer is Scale layer, since we need to normalize the input values to be in interval (0,1). Then we created two sequence of Convolution, Pooling layers. Once we done with that, we can add two Dense layers with 64 and 32 neurons with TanH activation function. The last layer is output layer that must follow the output dimension, and Softmax activation function.

Once network model is defined, we can move to the next step: Setting learning and training parameters.

Learning parameters can be defined through the Learning parameters interface: For this model we can select:

  • AdamLearner with 0.005 rate and 0.9 momentum value. Loss function is Classification Error, and the evaluation function is Classification Accuracy

In order to define the training parameters we switch to Training tab page and setup:

  • Number of epoch
  • Minibatch size
  • Progress frequency
  • Randomize minibatch during training

Now we have enough information to start model training. The training process is started by selecting Run command from the application ribbon. In order to get good model we need to train the model at least few thousands epoch. The following image shows trained model with training history charts.

The model is trained with exactly of 4071 epochs, with network parameters mentioned above. As can be seen from the upper chart, mini-batch loss function was CrossEntropyWithSoftmax, while the evaluation function was classification accuracy.  The bottom chart shows performance of the training and validation data sets for each 4071 epoch. We can also recognize that validation data set has roughly the same accuracy as training data set which indicates the model is trained well.  More details about model performance can be seen on the next image:

Upper charts of the image above show actual and predicted values for training (left) and validation (right). Most of the point values are blue and overlap the orange which indicates that most of value are correctly predicted. The charts can be zoomed and view details of each value.The bottom part of the evaluation show performance parameters of the model for corresponded data set. As can be seen the trained model has 0.91 overall accuracy for training data set and 0.826 overall accuracy for validation data set, which indicate pretty good accuracy of the model. Moreover, the next two images shows confusion matrix for the both data sets, which in details shows how model predict all 10 labels.

The last part of the post is testing model for test data set. For that purpose we selected 10 random images from each label of the test set, and evaluate the model. The following images shows the model correctly predicted all 10 images.


ANNdotNET v1.2 image classification module offers complete data preparation and model development for image classification. The user can prepare data for training, create network model with Neural Network Designer, and perform set of statistical tools against trained model in order to validate and evaluate model. The important note is that the data set of images must be stored on specific location in order to use this trained model shown in the blog post. The trained model, as well as mlcofig files, can be load directly into ANNdotNET project explorer by doublick on feed example.

ANNdotNET as open source project provides outstanding way in complete development of deep learning model.

Export options in ANNdotNET

ANNdotNET v1.0 has been release a few weeks ago, and the feedback is very positive. Also up to now there is no any blocking or serious bug in the release which makes me very happy. For this blog post we are going through Export options in ANNdotNET.

The ANNdotNET supposed to be an application which can offer whole life-cycle for  machine learning project: from the defining raw data set, cleaning and features engineering, to training and evaluation of the model. Also with different mlconfig files within the same project, the user has ability to create as many ml configurations as wants. Once the user select the best ml configuration, and the training and evaluation process completes, the next step in ML project life-cycle is the model deployment/export.

Currently, ANNdotNET defines three export options:

  • Export model result to CSV file,
  • Export model and model result to Excel, and
  • Export model in CNTK file format.

With those three export option, we can achieve many ML scenarios.

Export to CSV

Export to CSV provides exporting actual and predicted values of testing data set to comma separated txt file. In case the testing data set is not provided, the result of validation data set will exported. In case nor testing nor validation dataset are not provided the export process is terminated.

The export process starts by selecting appropriate mlconfig file. The network model must be trained prior to be exported.

2018-10-22_9-35-07.pngOnce the export process completes, the csv file is created on disk. We can import the exported result in Excel, and similar content will be shows as image below:


Exported result is shows in two columns. The actual and predicted values. In case the classification result is exported, in the header the information about class values are exported.

Export to Excel

Export to Excel option is more than just exporting the result. In fact, it is deployment of the model into Excel environment. Beside exporting all defined data sets (training, Validation, and Test) the model is also exported. Predicted values are calculated by using ANNdotNET Excel Add-in, which the model evaluation looks like calling ordinary Excel formula.  More information how it works can be found here.


Exported xlsx file can be opened, and the further analysis for the model and related data sets can be continued. The following image shows exported model for Concrete Slum Test example. Since only two data sets are defined (training and validation) those data sets are exported. As can be seen the predicted column is not filled, only the row is filled with the formula that must be evaluated by inserting equal sign “=” in front of the formula.


Once the formula is evaluated for the first row, we can use Excel trick to copy it on other rows.

The same situation is for other data sets separated in Excel Worksheets.

Export to CNTK

The last option allows to export CNTK trained model in CNTK format. Also ONNX format will be supported as soon as being available on CNTK for C# library. This option is handy in situation where trained CNTK model being evaluated in other solutions.

For this blog post, there is a short video which the reader can see all three options in actions.

Sentiment Analysis using ANNdotNET

The October 2018 issue of MSDN magazine brings the article “Sentiment Analysis Using CNTK” written by James McCaffrey. I was wondering if I can implement this solution in ANNdotNET as Dr. McCaffrey written in the magazine. Indeed I have implemented complete solution in less than 5 minutes.

In this blog post I am going to walk you through this very good and well written MSDN article example. I am not going to repeat the text written in the MSDN article, so it is recommendation to read the article first, and back here and implement the example in ANNdotNET. Since the ANNdotNET is GUI tool, it is interesting to see all great visualizations during the model training and evaluation. Also the ANNdotNET provides complete binary model evaluation by providing the confusion matrix, ROC Curve, and other binary performance parameters, this example makes more interesting and valuable to read.

Whole example is implemented in five steps.

Step 1: Prepare files and folder structure

First we need to create several folders and files in order to create empty annproject. This manual creation of folders are necessary because ANNdotNET v1.0 has not option to create Empty project. This will be added in the next version.

So first, create the following set of hierarchically ordered folders:

  • SentimentAnalysis
    • MoveReview
      • data

The following figure shows this set of folder.


Step 2: Download data sets used in the example.

Only thing we need from the MSDN article is train and test data sets. The data can be downloaded from the MSDN sample: Once the zip file is downloaded unzip the sample, and copy files: imdb_sparse_train_50w.txt and indb_sparse_test_50w.txt to data folder as image above shows.

Step 3: Create MoviewReview.ann and LSTM-Net.mlconfig files

  • Open Notepad and create file with the following content:
project:|Name:MovieReview |Type:NoRawData |MLConfigs:LSTM-Net
parser:|RowSeparator:rn |ColumnSeparator: ; |Header:0 |SkipLines:0

Save file in SentimenAnalysis folder as MovieReview.ann. The following picture shows saved annproject file on disk.


Now open Notepad again, create a new empty file. The empty file is supposed to be  mlconfig file with the content shown below. Don’t worry about the content of the file, since all those details will be visible once we open it with ANNdotNET. If you want to know more about structure of the mlconfig file, please refer to this wiki page of the ANNdotNET project.

features:|x 129892 1
labels:|y 2 0
network:|Layer:Embedding 50 0 0 None 0 0 |Layer:LSTM 25 25 0 TanH 1 1 |Layer:Dense 2 0 0 Softmax 0 0
learning:|Type:AdamLearner |LRate:0.01 |Momentum:0.85 |Loss:CrossEntropyWithSoftmax |Eval:ClassificationAccuracy |L1:0 |L2:0
training:|Type:Default |BatchSize:250 |Epochs:400 |Normalization:0 |RandomizeBatch:0 |SaveWhileTraining:0 |FullTrainingSetEval:1 |ProgressFrequency:1 |ContinueTraining:0 |TrainedModel:
paths:|Training:data\imdb_sparse_train_50w.txt |Validation:data\imdb_sparse_test_50w.txt |Test:data\imdb_sparse_test_50w.txt |TempModels:temp_models |Models:models |Result:LSTM-Net_result.csv |Logs:log<span id="mce_SELREST_end" style="overflow:hidden;line-height:0;"></span>

The file should be saved in the MovieReview folder with LSTM-Net.mlconfig file name. The next image shows where mlconfig file is stored.


Step 4. Open annproject file with ANNdotNET GUI tool

Now we have setup everything in order to open and train sentiment analysis example with ANNdotNET. Since ANNdotNET implements MLEngine which is based on CNTK, data sets are compatible and can be read by the trainer. In order to get better result we have changed learning parameter a little bit. Instead of SGD we used AdamLearner.

In case you don’t have ANNdotNET tool installed on your machine, just go to release section and download the latest version. Or clone the GitHub repository and run it within the Visual Studio. All information about how to run ANNdotNET as standalone application or as the Visual Studio solution can be found at GitHub page

After simple unzipping binaries of the ANNdotNET on your machine, run it by simply selecting anndotnet.wnd.exe file. Once the ANNdotNET is running, click the Open application command and select the MoveReview.ann file. In a second the application loads the project with corresponded mlconfig file. From the project explorer, click on LSTM-NET three item, and similar content as image below should be appeared.


Everything we have written into mlconfig file are now shown in the Network settings tab page.

  1. Input layer with 129892 dimensions
  2. Output layer with 2 dimension (binary problem)
  3. Learning parameters:
    1. AdamLearner, with 0.01 lr and 0.85 momentum,
    2. Loss Function is CrossEntropywithSoftmax
    3. Evaluation function is ClassificationAccuracy
  4. NNetwork Designer shows typical LSTM recurrent network

Step 5. Training and Evaluation of the Example

Now that we reviewed the network settings, we can switch to the train tab page, and review the training parameters. Since we already setup training parameters in the mlconfig file, we don’t need to change anything.

Start training process by click on the Run application command. After some time we should see the following result:


If we switch to Evaluation page we can perform some statistics analysis in order to evaluate if the model is good or not. Once the evaluation tab page is shown, click on Refresh button to evaluate the model against training and validation data stets.


The left statistics are for the training dataset, and the left side is for the validation data set. As can be seen, the model perfectly predicted all data from the training data set, and about 70% of accuracy described the validation data set. Off cource, the model is not good as we expected for the production, but for this demonstration is good enough. There are also two buttons to show ROC curve, and other binary performance parameters, for both data sets, which the reader my taste.

That’s all needed in order to have complete Sentiment Analysis exemple setup and running. In case you want complete ANNdotNET project, it can be downloaded from here.