1     [TestClass]
 2     public class CSLogisticMultiTests
 3     {
 4         LogisticMulti _lc = null;
 5         double[][] _trainData;
 6         double[][] _testData;
 7 
 8         public CSLogisticMultiTests()
 9         {
10             int numFeatures = 4;
11             int numClasses = 3;
12             int numRows = 1000;
13             int seed = 42;
14             var data = LogisticMultiProgram.MakeDummyData(numFeatures, numClasses, numRows, seed);
15             LogisticMultiProgram.SplitTrainTest(data, 0.80, 7, out _trainData, out _testData);
16             _lc = new LogisticMulti(numFeatures, numClasses);
17 
18             int maxEpochs = 100;
19             double learnRate = 0.01;
20             double decay = 0.10;
21             _lc.Train(_trainData, maxEpochs, learnRate, decay);
22         }
23 
24         [TestMethod]
25         public void GetWeights_ReturnExpected()
26         {
27             double[][] bestWts = _lc.GetWeights();
28             var expected = 13.939104508387803;
29             var actual = bestWts[0][0];
30             Assert.AreEqual(expected, actual);
31         }
32 
33         [TestMethod]
34         public void GetBiases_ReturnExpected()
35         {
36             double[] bestBiases = _lc.GetBiases();
37             var expected = 11.795019237894717;
38             var actual = bestBiases[0];
39             Assert.AreEqual(expected, actual);
40         }
41 
42         [TestMethod]
43         public void GetTrainAccuracy_ReturnExpected()
44         {
45             var expected = 0.92125;
46             var actual = _lc.Accuracy(_trainData);
47             Assert.AreEqual(expected, actual);
48         }
49 
50         [TestMethod]
51         public void GetTestAccuracy_ReturnExpected()
52         {
53             var expected = 0.895;
54             double actual = _lc.Accuracy(_testData);
55             Assert.AreEqual(expected, actual);
56         }
57     }
58 

1       Random rnd = new Random(seed); 
2       double[][] wts = new double[numFeatures][];
3       for (int i = 0; i < numFeatures; ++i)
4         wts[i] = new double[numClasses];
5       double hi = 10.0;
6       double lo = -10.0;
7       for (int i = 0; i < numFeatures; ++i)
8         for (int j = 0; j < numClasses; ++j)
9           wts[i][j] = (hi - lo) * rnd.NextDouble() + lo;

1 let rnd = new Random(seed)    
2 let hi = 10.0
3 let lo = -10.0
4 let wts = Array.create numFeatures (Array.create numClasses 1.)
5 let wts' = wts |> Array.map(fun row -> row |> Array.map(fun col -> (hi - lo) * rnd.NextDouble() + lo))
6 

1       double[] biases = new double[numClasses];
2       for (int i = 0; i < numClasses; ++i)
3         biases[i] = (hi - lo) * rnd.NextDouble() + lo;
4 

1 let biases = Array.create numClasses 1.
2 let biases' = biases |> Array.map(fun row -> (hi - lo) * rnd.NextDouble() + lo)
3 

 1       double[][] result = new double[numRows][]; // allocate result
 2       for (int i = 0; i < numRows; ++i)
 3         result[i] = new double[numFeatures + numClasses];
 4 
 5       for (int i = 0; i < numRows; ++i) // create one row at a time
 6       {
 7         double[] x = new double[numFeatures]; // generate random x-values
 8         for (int j = 0; j < numFeatures; ++j)
 9           x[j] = (hi - lo) * rnd.NextDouble() + lo;
10 
11         double[] y = new double[numClasses]; // computed outputs storage
12         for (int j = 0; j < numClasses; ++j) // compute z-values
13         {
14           for (int f = 0; f < numFeatures; ++f)
15             y[j] += x[f] * wts[f][j];
16           y[j] += biases[j];
17         }
18 
19         // determine loc. of max (no need for 1 / 1 + e^-z)
20         int maxIndex = 0;
21         double maxVal = y[0];
22         for (int c = 0; c < numClasses; ++c)
23         {
24           if (y[c] > maxVal)
25           {
26             maxVal = y[c];
27             maxIndex = c;
28           }
29         }
30         
31         for (int c = 0; c < numClasses; ++c) // convert y to 0s or 1s
32           if (c == maxIndex)
33             y[c] = 1.0;
34           else
35             y[c] = 0.0;
36 
37         int col = 0; // copy x and y into result
38         for (int f = 0; f < numFeatures; ++f)
39           result[i][col++] = x[f];
40         for (int c = 0; c < numClasses; ++c)
41           result[i][col++] = y[c];
42       }
43 

 1 let x = Array.create numFeatures 1.
 2 let x' = x |> Array.map(fun row -> (hi - lo) * rnd.NextDouble() + lo)
 3 
 4 let xWts = Array.zip x' wts'
 5 let xWts' = xWts |> Array.map(fun (x,wts) -> wts |> Array.sumBy(fun wt -> wt * x))
 6 
 7 let y = Array.create numClasses 1.
 8 let yWts = Array.zip y xWts'
 9 let y' = yWts |> Array.map(fun (y,xwt) -> y + xwt)
10  
11 let yBias = Array.zip y' biases'
12 let y'' = yBias |> Array.map(fun (y,bias) -> y + bias)
13 
14 let maxVal = y'' |> Array.max
15 
16 let y''' = y'' |> Array.map(fun y -> if y = maxVal then 1. else 0.)
17 
18 let xy = Array.append x' y'''
19 let result = Array.create numRows xy