Network Programming in .NET

Thanks to James Mc Caffrey, code from  Test Run for MSDN Magazine April 2018

using System;

namespace LSTM_IO

{

class LSTM_IO_Program

{

static void Main(string[] args)

{

Console.WriteLine(“\nBegin LSTM IO demo \n”);

Console.WriteLine(“Creating an n=2 input, m=3 state LSTM cell”);

Console.WriteLine(“Setting LSTM weights and biases to small arbitrary values \n”);

Console.WriteLine(“Sending input = (1.0, 2.0) to LSTM \n”);

float[][] xt = MatFromArray(new float[] { 1.0f, 2.0f }, 2, 1);

float[][] h_prev = MatFromArray(new float[] { 0.0f, 0.0f, 0.0f }, 3, 1);

float[][] c_prev = MatFromArray(new float[] { 0.0f, 0.0f, 0.0f }, 3, 1);

float[][] W = MatFromArray(new float[] { 0.01f, 0.02f,

0.03f, 0.04f,

0.05f, 0.06f }, 3, 2);

float[][] U = MatFromArray(new float[] { 0.07f, 0.08f, 0.09f,

0.10f, 0.11f, 0.12f,

0.13f, 0.14f, 0.15f }, 3, 3);

float[][] b = MatFromArray(new float[] { 0.16f, 0.17f, 0.18f }, 3, 1);

float[][] Wf = MatCopy(W); float[][] Wi = MatCopy(W);

float[][] Wo = MatCopy(W); float[][] Wc = MatCopy(W);

float[][] Uf = MatCopy(U); float[][] Ui = MatCopy(U);

float[][] Uo = MatCopy(U); float[][] Uc = MatCopy(U);

float[][] bf = MatCopy(b); float[][] bi = MatCopy(b);

float[][] bo = MatCopy(b); float[][] bc = MatCopy(b);

float[][] ht, ct;

float[][][] result;

result = ComputeOutputs(xt, h_prev, c_prev,

Wf, Wi, Wo, Wc, Uf, Ui, Uo, Uc, bf, bi, bo, bc);

ht = result[0]; // output

ct = result[1]; // new cell state

Console.WriteLine(“Output is:”);

MatPrint(ht, 4, true);

Console.WriteLine(“New cell state is:”);

MatPrint(ct, 4, true);

Console.WriteLine(“=====”);

Console.WriteLine(“\nSending input = (3.0, 4.0) to LSTM \n”);

h_prev = MatCopy(ht);

c_prev = MatCopy(ct);

xt = MatFromArray(new float[] { 3.0f, 4.0f }, 2, 1);

result = ComputeOutputs(xt, h_prev, c_prev,

Wf, Wi, Wo, Wc, Uf, Ui, Uo, Uc, bf, bi, bo, bc);

ht = result[0];

ct = result[1];

Console.WriteLine(“Output is:”);

MatPrint(ht, 4, true);

Console.WriteLine(“New cell state is:”);

MatPrint(ct, 4, true);

Console.WriteLine(“End LSTM demo “);

Console.ReadLine();

} // Main

static float[][][] ComputeOutputs(float[][] xt, float[][] h_prev, float[][] c_prev,

float[][] Wf, float[][] Wi, float[][] Wo, float[][] Wc,

float[][] Uf, float[][] Ui, float[][] Uo, float[][] Uc,

float[][] bf, float[][] bi, float[][] bo, float[][] bc)

{

float[][] ft = MatSig(MatSum(MatProd(Wf, xt), MatProd(Uf, h_prev), bf));

float[][] it = MatSig(MatSum(MatProd(Wi, xt), MatProd(Ui, h_prev), bi));

float[][] ot = MatSig(MatSum(MatProd(Wo, xt), MatProd(Uo, h_prev), bo));

float[][] ct = MatSum(MatHada(ft, c_prev),

MatHada(it, MatTanh(MatSum(MatProd(Wc, xt), MatProd(Uc, h_prev), bc))));

float[][] ht = MatHada(ot, MatTanh(ct));

float[][][] result = new float[2][][];

result[0] = MatCopy(ht);

result[1] = MatCopy(ct);

return result;

}

// Matrix routines

static float[][] MatCreate(int rows, int cols)

{

float[][] result = new float[rows][];

for (int i = 0; i < rows; ++i)

result[i] = new float[cols];

return result;

}

static float[][] MatFromArray(float[] arr, int rows, int cols)

{

if (rows * cols != arr.Length)

throw new Exception(“xxx”);

float[][] result = MatCreate(rows, cols);

int k = 0;

for (int i = 0; i < rows; ++i)

for (int j = 0; j < cols; ++j)

result[i][j] = arr[k++];

return result;

}

static float[][] MatCopy(float[][] m)

{

int rows = m.Length; int cols = m[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i)

for (int j = 0; j < cols; ++j)

result[i][j] = m[i][j];

return result;

}

static float[][] MatProd(float[][] a, float[][] b)

{

int aRows = a.Length; int aCols = a[0].Length;

int bRows = b.Length; int bCols = b[0].Length;

if (aCols != bRows)

throw new Exception(“xxx”);

float[][] result = MatCreate(aRows, bCols);

for (int i = 0; i < aRows; ++i) // each row of a

for (int j = 0; j < bCols; ++j) // each col of b

for (int k = 0; k < aCols; ++k) // could use k < bRows

result[i][j] += a[i][k] * b[k][j];

return result;

}

// element-wise functions

static float[][] MatSig(float[][] m)

{

// element-wise sigmoid

int rows = m.Length; int cols = m[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i) // each row

for (int j = 0; j < cols; ++j) // each col

result[i][j] = Sigmoid(m[i][j]);

return result;

}

static float[][] MatTanh(float[][] m)

{

// element-wise tanh

int rows = m.Length; int cols = m[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i) // each row

for (int j = 0; j < cols; ++j) // each col

result[i][j] = Tanh(m[i][j]);

return result;

}

static float Sigmoid(float x)

{

if (x < -10.0) return 0.0f;

else if (x > 10.0) return 1.0f;

return (float)(1.0 / (1.0 + Math.Exp(-x)));

}

static float Tanh(float x)

{

if (x < -10.0) return -1.0f;

else if (x > 10.0) return 1.0f;

return (float)(Math.Tanh(x));

}

static float[][] MatHada(float[][] a, float[][] b)

{

// Hadamard element-wise multiplication

// assumes a, b have same shape

int rows = a.Length; int cols = a[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i)

for (int j = 0; j < cols; ++j)

result[i][j] = a[i][j] * b[i][j];

return result;

}

static float[][] MatSum(float[][] a, float[][] b)

{

int rows = a.Length; int cols = a[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i)

for (int j = 0; j < cols; ++j)

result[i][j] = a[i][j] + b[i][j];

return result;

}

static float[][] MatSum(float[][] a, float[][] b, float[][] c)

{

int rows = a.Length; int cols = a[0].Length;

float[][] result = MatCreate(rows, cols);

for (int i = 0; i < rows; ++i)

for (int j = 0; j < cols; ++j)

result[i][j] = a[i][j] + b[i][j] + c[i][j];

return result;

}

static void MatPrint(float[][] Mat, int dec, bool nl)

{

for (int i = 0; i < Mat.Length; ++i)

{

for (int j = 0; j < Mat[0].Length; ++j)

{

Console.Write(Mat[i][j].ToString(“F” + dec) + ” “);

}

Console.WriteLine(“”);

}

if (nl == true) Console.WriteLine(“”);

}

} // Program

} // ns

0.4 + 0.4 = 0.79 … well done! 

Jokes aside, this is an example of how to use machine learning in C# to predict sequences, in this case to say the sequence of two inputs should result in the sum of the two inputs.

TLDR; the Github repo is here : https://github.com/infiniteloopltd/SharpML-Recurrent

It is 99.9% based on Andrew Fry’s code, but I have modified the dataset generator, that instead of modelling an XOR gate, it models a simple adder. I noticed that the values have to be between 0 and 1, but I guess, you just shift your range to that.

private static List<DataSequence> GetTrainingData()
{

var result = new List<DataSequence>();
for (var a = 0.0; a < 0.5; a += 0.1)
{
for (var b = 0.0; b < 0.5; b += 0.1)
{
var sum = a + b;
result.Add(new DataSequence(new List<DataStep>() { new DataStep(new[] { a, b }, new[] { sum }) }));
}
}

return result;
}

This simply provides a dataset of every combination of numbers in 0.1 increments between 0 and 0.5, and indicates the sum.

Obviously this training data can be improved, but it’s just a proof of concept, as you can imagine!

Next step is to add another dimension to the output. But that’s work for another day!

If you would like to learn about SQL server indexes, and SQL server performance in general, but can’t get your hands on a large dataset that really tests the limits of your SQL server, then here is a script that generates a huge dataset, based on random data.

create table Test1
(
id int identity(1,1),
guid varchar(36) default newid(),
dateCreated datetime default getdate(),
number float default rand()
)

while 1=1
Begin
insert into Test1 default values
end

You just let it run for as long as you like, then stop it whenever you have enough rows.