public void add <Type>(Type n) { if (n is NNMatrix) { for (int i = 0; i < this.rows; i++) { for (int j = 0; j < this.cols; j++) { NNMatrix mat = (NNMatrix)(object)n; this.data[i][j] += mat.data[i][j]; } } } else { for (int i = 0; i < this.rows; i++) { for (int j = 0; j < this.cols; j++) { float val = (float)(object)n; this.data[i][j] += val; } } } }
public static NNMatrix multiply(NNMatrix a, NNMatrix b) { if (a.cols != b.rows) { Debug.Log("Columns of A must match rows of B."); return(null); } NNMatrix result = new NNMatrix(a.rows, b.cols); for (int i = 0; i < result.rows; i++) { for (int j = 0; j < result.cols; j++) { float sum = 0f; for (int k = 0; k < a.cols; k++) { sum += a.data[i][k] * b.data[k][j]; } result.data[i][j] = sum; } } return(result); }
public void train(List <float> input_list, List <float> target_list) { NNMatrix inputs = NNMatrix.fromList(input_list); NNMatrix hidden = NNMatrix.multiply(this.weights_ih, inputs); hidden.add(this.bias_h); // activate function hidden.map(ActivateFunction.sigmoid); NNMatrix outputs = NNMatrix.multiply(this.weights_ho, hidden); outputs.add(this.bias_o); outputs.map(ActivateFunction.sigmoid); NNMatrix targets = NNMatrix.fromList(target_list); // calculate the error // ERROR = TARGETS(答え) - OUTPUTS(実際の出力) NNMatrix output_errors = NNMatrix.subtract(targets, outputs); //var gradients = outputs * (1-outputs); // calculate gradient NNMatrix gradients = NNMatrix.map(outputs, ActivateFunction.dsigmoid); gradients.multiply(output_errors); gradients.multiply(this.learning_rate); // calculate deltas NNMatrix hidden_T = NNMatrix.transpose(hidden); NNMatrix weights_ho_deltas = NNMatrix.multiply(gradients, hidden_T); // Adjust the weights by deltas this.weights_ho.add(weights_ho_deltas); // Adjust bias by its delta (which is just the gradients) this.bias_o.add(gradients); // calculate the hidden layer errors NNMatrix who_t = NNMatrix.transpose(this.weights_ho); NNMatrix hidden_errors = NNMatrix.multiply(who_t, output_errors); // calculate hidden gradients NNMatrix hidden_gradient = NNMatrix.map(hidden, ActivateFunction.dsigmoid); hidden_gradient.multiply(hidden_errors); hidden_gradient.multiply(this.learning_rate); // calculate input->hidden deltas NNMatrix input_T = NNMatrix.transpose(inputs); NNMatrix weight_ih_deltas = NNMatrix.multiply(hidden_gradient, input_T); this.weights_ih.add(weight_ih_deltas); // Adjust bias by its delta (which is just the hiddent gradients) this.bias_h.add(hidden_gradient); }
private void Init(NNMatrix m) { for (int i = 1; i <= m.NbRows; i++) { for (int j = 1; j <= m.NbCols; j++) { m[i - 1, j - 1] = i * 10 + j; } } }
public static NNMatrix fromList(List <float> list) { NNMatrix m = new NNMatrix(list.Count, 1); for (int i = 0; i < list.Count; i++) { m.data[i][0] = list[i]; } return(m); }
public void MatrixConstructors() { var m1 = new NNMatrix(2, 3); Assert.AreEqual(m1.NbRows, 2); Assert.AreEqual(m1.NbCols, 3); Init(m1); var m2 = new NNMatrix(data); Assert.AreEqual(m2.NbRows, 2); Assert.AreEqual(m2.NbCols, 3); Assert.AreEqual(m1.ToString(), m2.ToString()); }
public static NNMatrix transpose(NNMatrix matrix) { NNMatrix result = new NNMatrix(matrix.cols, matrix.rows); for (int i = 0; i < matrix.rows; i++) { for (int j = 0; j < matrix.cols; j++) { result.data[j][i] = matrix.data[i][j]; } } return(result); }
public static NNMatrix subtract(NNMatrix a, NNMatrix b) { NNMatrix result = new NNMatrix(a.rows, a.cols); for (int i = 0; i < result.rows; i++) { for (int j = 0; j < result.cols; j++) { result.data[i][j] = a.data[i][j] - b.data[i][j]; } } return(result); }
public void MatrixCalc() { // W*I+B test calculattin Input*Weights + Biases int nbInput = 6; int nbOutput = 3; NNArray I = NNArray.Random(nbInput); NNMatrix W = NNMatrix.Random(nbInput, nbOutput); NNArray B = NNArray.Random(nbOutput); var tmp = W * I; var O = tmp + B; Assert.AreEqual(O.Length, nbOutput); }
public static NNMatrix map(NNMatrix matrix, System.Func <float, float> func) { NNMatrix result = new NNMatrix(matrix.rows, matrix.cols); for (int i = 0; i < matrix.rows; i++) { for (int j = 0; j < matrix.cols; j++) { float val = matrix.data[i][j]; result.data[i][j] = func(val); } } return(result); }
public NeuralNetwork(int _input_nodes, int _hidden_nodes, int _output_nodes) { this.input_nodes = _input_nodes; this.hidden_nodes = _hidden_nodes; this.output_nodes = _output_nodes; // weight between input and hidden this.weights_ih = new NNMatrix(this.hidden_nodes, this.input_nodes); this.weights_ih.randomize(); // weight between hidden and output this.weights_ho = new NNMatrix(this.output_nodes, this.hidden_nodes); this.weights_ho.randomize(); this.bias_h = new NNMatrix(this.hidden_nodes, 1); this.bias_o = new NNMatrix(this.output_nodes, 1); }
public void MatrixMult() { NNMatrix M1 = NNMatrix.Random(2, 2); // 3 row * 4 Columns NNMatrix M2 = NNMatrix.Identity(2, 2); var M3 = M1 * M2; Assert.IsTrue(M1.Equals(M3)); M1 = NNMatrix.Random(3, 4); // 3 row * 4 Columns M2 = NNMatrix.Random(4, 2); M3 = M1 * M2; Assert.AreEqual(M3.NbRows, 3); Assert.AreEqual(M3.NbCols, 2); }
public List <float> feedforward(List <float> input_list) { NNMatrix inputs = NNMatrix.fromList(input_list); NNMatrix hidden = NNMatrix.multiply(this.weights_ih, inputs); hidden.add(this.bias_h); // activate function hidden.map(ActivateFunction.sigmoid); NNMatrix output = NNMatrix.multiply(this.weights_ho, hidden); output.add(this.bias_o); output.map(ActivateFunction.sigmoid); return(output.toList()); }
public NeuralNetwork copy() { int _input_nodes = this.input_nodes; int _hidden_nodes = this.hidden_nodes; int _output_nodes = this.output_nodes; NNMatrix wih = this.weights_ih; NNMatrix who = this.weights_ho; float lr = this.learning_rate; NNMatrix bh = this.bias_h; NNMatrix oh = this.bias_o; NeuralNetwork nn = new NeuralNetwork(_input_nodes, _hidden_nodes, _output_nodes); nn.weights_ih = wih; nn.weights_ho = who; nn.learning_rate = lr; nn.bias_h = bh; nn.bias_o = oh; return(nn); }
public void MatrixPerformance() { // W*I+B test calculattin Input*Weights + Biases int nbInput = 300; int nbOutput = 200; NNArray I = NNArray.Random(nbInput); NNMatrix W = NNMatrix.Random(nbInput, nbOutput); NNArray B = NNArray.Random(nbOutput); int count = 200; DateTime start; DateTime end; double duration; // Not optimized start = DateTime.Now; for (int i = 0; i < count; i++) { NNArray res = W * I + B; } end = DateTime.Now; duration = (end - start).TotalMilliseconds / 1000; Console.WriteLine("Duration Non Optimized: "+duration); // Optimized NNArray O = NNArray.Random(nbOutput); start = DateTime.Now; for (int i = 0; i < count; i++) { W.Multiply(I,O); O.Add(B,O); } end = DateTime.Now; duration = (end - start).TotalMilliseconds / 1000; Console.WriteLine("Duration Optimized: " + duration); }
public void MatrixRowCol() { var m1 = new NNMatrix(data); string s1 = m1.ToString(); var m2 = new NNMatrix(2, 3); Init(m2); Assert.AreEqual(m1.ToString(), m2.ToString()); NNMatrix M = new NNMatrix(2, 3); // 2 row * 3 Columns M[0, 0] = 11; M[0, 1] = 12; M[0, 2] = 13; M[1, 0] = 11; M[1, 1] = 12; M[1, 2] = 13; var s = M.ToString(); Assert.AreEqual(2, m1.NbRows); Assert.AreEqual(2, M.NbRows); Assert.AreEqual(3, m1.NbCols); Assert.AreEqual(3, M.NbCols); }
/// <summary> /// 计算DOP值,返回可见卫星数 /// </summary> /// <param name="tle"></param> /// <param name="time">要计算的时间</param> /// <param name="B">测站的,单位:度</param> /// <param name="L"></param> /// <param name="H">单位:米</param> /// <param name="cor_limit">截止高度角,度</param> /// <param name="GDOP"></param> /// <param name="PDOP"></param> /// <param name="HDOP"></param> /// <param name="VDOP"></param> /// <param name="TDOP"></param> /// <returns></returns> public static int CalcDops(Tle[] tles, DateTime time, double B, double L, double H, double cor_limit, ref double GDOP, ref double PDOP, ref double HDOP, ref double VDOP, ref double TDOP) { double x2 = 0; double y2 = 0; double z2 = 0; //测站坐标 BLToXYZ(B / 180 * Math.PI, L / 180 * Math.PI, H, ref x2, ref y2, ref z2); ArrayList temp = new ArrayList(); Site siteEquator2 = new Site(B, L, H); Tle tle; Orbit orbit; Eci eci; CoordGeo cg; int sum = 0; for (int i = 0; i < tles.Length; i++) { tle = tles[i]; orbit = new Orbit(tle); eci = orbit.GetPosition(time); double x = eci.Position.X * 1000; double y = eci.Position.Y * 1000; double z = eci.Position.Z * 1000; //化成米 cg = eci.ToGeo(); CoordTopo topoLook = siteEquator2.GetLookAngle(eci); topoLook.Elevation = Globals.Rad2Deg(topoLook.Elevation); topoLook.Azimuth = Globals.Rad2Deg(topoLook.Azimuth); //化成度 if (topoLook.Elevation > cor_limit) { sum++; double d_x = x - x2; double d_y = y - y2; double d_z = z - z2; double r2 = Math.Sqrt(d_x * d_x + d_y * d_y + d_z * d_z); temp.Add(d_x / r2); temp.Add(d_y / r2); temp.Add(d_z / r2); } } NNMatrix Q = new NNMatrix(sum, 4); NNMatrix Q_x = new NNMatrix(4, 4); for (int j = 0; j < temp.Count; j++) { if ((j + 1) % 3 == 1) { Q.Matrix[j / 3, 0] = (double)temp[j]; } else if ((j + 1) % 3 == 2) { Q.Matrix[j / 3, 1] = (double)temp[j]; } else if ((j + 1) % 3 == 0) { Q.Matrix[j / 3, 2] = (double)temp[j]; } Q.Matrix[j / 3, 3] = 1; } Q_x = NNMatrix.Invers(NNMatrix.Transpos(Q) * Q); GDOP = Math.Sqrt(Q_x.Matrix[0, 0] + Q_x.Matrix[1, 1] + Q_x.Matrix[2, 2] + Q_x.Matrix[3, 3]); PDOP = Math.Sqrt(Q_x.Matrix[0, 0] + Q_x.Matrix[1, 1] + Q_x.Matrix[2, 2]); HDOP = Math.Sqrt(Q_x.Matrix[0, 0] + Q_x.Matrix[1, 1]); VDOP = Math.Sqrt(Q_x.Matrix[2, 2]); TDOP = Math.Sqrt(Q_x.Matrix[3, 3]); return(sum); }
public void mutate() { this.weights_ih = NNMatrix.map(this.weights_ih, NNUtils.mutate); this.weights_ho = NNMatrix.map(this.weights_ho, NNUtils.mutate); }