/// <summary> /// Compute finite difference coefficients according to the method provided here: /// http://en.wikipedia.org/wiki/Finite_difference_coefficients /// </summary> /// <returns>An array of the coefficients for FD.</returns> public double[] CreateCoefficients() { var result = new double[_pointCount]; var delts = new Matrix(_pointCount, _pointCount); double[][] t = delts.Data; for (int j = 0; j < _pointCount; j++) { double delt = (j - _center); double x = 1.0; for (int k = 0; k < _pointCount; k++) { t[j][k] = x / EncogMath.Factorial(k); x *= delt; } } Matrix invMatrix = delts.Inverse(); double f = EncogMath.Factorial(_pointCount); for (int k = 0; k < _pointCount; k++) { result[k] = (Math .Round(invMatrix.Data[1][k] * f)) / f; } return(result); }
/// <summary> /// Calculate G. /// </summary> /// <param name="network">The network to calculate for.</param> /// <param name="e">The event to calculate for.</param> /// <param name="parents">The parents.</param> /// <returns>The value for G.</returns> public double CalculateG(BayesianNetwork network, BayesianEvent e, IList <BayesianEvent> parents) { double result = 1.0; int r = e.Choices.Count; var args = new int[parents.Count]; do { double n = EncogMath.Factorial(r - 1); double d = EncogMath.Factorial(CalculateN(network, e, parents, args) + r - 1); double p1 = n / d; double p2 = 1; for (int k = 0; k < e.Choices.Count; k++) { p2 *= EncogMath.Factorial(CalculateN(network, e, parents, args, k)); } result *= p1 * p2; } while (EnumerationQuery.Roll(parents, args)); return(result); }
/// <summary> /// QR Decomposition, computed by Householder reflections. /// </summary> /// <param name="A">Structure to access R and the Householder vectors and compute Q.</param> public QRDecomposition(Matrix A) { // Initialize. QR = A.GetArrayCopy(); m = A.Rows; n = A.Cols; Rdiag = new double[n]; // Main loop. for (int k = 0; k < n; k++) { // Compute 2-norm of k-th column without under/overflow. double nrm = 0; for (int i = k; i < m; i++) { nrm = EncogMath.Hypot(nrm, QR[i][k]); } if (nrm != 0.0) { // Form k-th Householder vector. if (QR[k][k] < 0) { nrm = -nrm; } for (int i = k; i < m; i++) { QR[i][k] /= nrm; } QR[k][k] += 1.0; // Apply transformation to remaining columns. for (int j = k + 1; j < n; j++) { double s = 0.0; for (int i = k; i < m; i++) { s += QR[i][k] * QR[i][j]; } s = -s / QR[k][k]; for (int i = k; i < m; i++) { QR[i][j] += s * QR[i][k]; } } } Rdiag[k] = -nrm; } }
/// <summary> /// Construct the singular value decomposition /// </summary> /// <param name="Arg">Rectangular matrix</param> public SingularValueDecomposition(Matrix Arg) { // Derived from LINPACK code. // Initialize. double[][] A = Arg.GetArrayCopy(); m = Arg.Rows; n = Arg.Cols; /* * Apparently the failing cases are only a proper subset of (m<n), so * let's not throw error. Correct fix to come later? if (m<n) { throw * new IllegalArgumentException("Jama SVD only works for m >= n"); } */ int nu = Math.Min(m, n); s = new double[Math.Min(m + 1, n)]; umatrix = EngineArray.AllocateDouble2D(m, nu); vmatrix = EngineArray.AllocateDouble2D(n, n); var e = new double[n]; var work = new double[m]; bool wantu = true; bool wantv = true; // Reduce A to bidiagonal form, storing the diagonal elements // in s and the super-diagonal elements in e. int nct = Math.Min(m - 1, n); int nrt = Math.Max(0, Math.Min(n - 2, m)); for (int k = 0; k < Math.Max(nct, nrt); k++) { if (k < nct) { // Compute the transformation for the k-th column and // place the k-th diagonal in s[k]. // Compute 2-norm of k-th column without under/overflow. s[k] = 0; for (int i = k; i < m; i++) { s[k] = EncogMath.Hypot(s[k], A[i][k]); } if (s[k] != 0.0) { if (A[k][k] < 0.0) { s[k] = -s[k]; } for (int i = k; i < m; i++) { A[i][k] /= s[k]; } A[k][k] += 1.0; } s[k] = -s[k]; } for (int j = k + 1; j < n; j++) { if ((k < nct) & (s[k] != 0.0)) { // Apply the transformation. double t = 0; for (int i = k; i < m; i++) { t += A[i][k] * A[i][j]; } t = -t / A[k][k]; for (int i = k; i < m; i++) { A[i][j] += t * A[i][k]; } } // Place the k-th row of A into e for the // subsequent calculation of the row transformation. e[j] = A[k][j]; } if (wantu & (k < nct)) { // Place the transformation in U for subsequent back // multiplication. for (int i = k; i < m; i++) { umatrix[i][k] = A[i][k]; } } if (k < nrt) { // Compute the k-th row transformation and place the // k-th super-diagonal in e[k]. // Compute 2-norm without under/overflow. e[k] = 0; for (int i = k + 1; i < n; i++) { e[k] = EncogMath.Hypot(e[k], e[i]); } if (e[k] != 0.0) { if (e[k + 1] < 0.0) { e[k] = -e[k]; } for (int i = k + 1; i < n; i++) { e[i] /= e[k]; } e[k + 1] += 1.0; } e[k] = -e[k]; if ((k + 1 < m) & (e[k] != 0.0)) { // Apply the transformation. for (int i = k + 1; i < m; i++) { work[i] = 0.0; } for (int j = k + 1; j < n; j++) { for (int i = k + 1; i < m; i++) { work[i] += e[j] * A[i][j]; } } for (int j = k + 1; j < n; j++) { double t = -e[j] / e[k + 1]; for (int i = k + 1; i < m; i++) { A[i][j] += t * work[i]; } } } if (wantv) { // Place the transformation in V for subsequent // back multiplication. for (int i = k + 1; i < n; i++) { vmatrix[i][k] = e[i]; } } } } // Set up the final bidiagonal matrix or order p. int p = Math.Min(n, m + 1); if (nct < n) { s[nct] = A[nct][nct]; } if (m < p) { s[p - 1] = 0.0; } if (nrt + 1 < p) { e[nrt] = A[nrt][p - 1]; } e[p - 1] = 0.0; // If required, generate U. if (wantu) { for (int j = nct; j < nu; j++) { for (int i = 0; i < m; i++) { umatrix[i][j] = 0.0; } umatrix[j][j] = 1.0; } for (int k = nct - 1; k >= 0; k--) { if (s[k] != 0.0) { for (int j = k + 1; j < nu; j++) { double t = 0; for (int i = k; i < m; i++) { t += umatrix[i][k] * umatrix[i][j]; } t = -t / umatrix[k][k]; for (int i = k; i < m; i++) { umatrix[i][j] += t * umatrix[i][k]; } } for (int i = k; i < m; i++) { umatrix[i][k] = -umatrix[i][k]; } umatrix[k][k] = 1.0 + umatrix[k][k]; for (int i = 0; i < k - 1; i++) { umatrix[i][k] = 0.0; } } else { for (int i = 0; i < m; i++) { umatrix[i][k] = 0.0; } umatrix[k][k] = 1.0; } } } // If required, generate V. if (wantv) { for (int k = n - 1; k >= 0; k--) { if ((k < nrt) & (e[k] != 0.0)) { for (int j = k + 1; j < nu; j++) { double t = 0; for (int i = k + 1; i < n; i++) { t += vmatrix[i][k] * vmatrix[i][j]; } t = -t / vmatrix[k + 1][k]; for (int i = k + 1; i < n; i++) { vmatrix[i][j] += t * vmatrix[i][k]; } } } for (int i = 0; i < n; i++) { vmatrix[i][k] = 0.0; } vmatrix[k][k] = 1.0; } } // Main iteration loop for the singular values. int pp = p - 1; int iter = 0; double eps = Math.Pow(2.0, -52.0); double tiny = Math.Pow(2.0, -966.0); while (p > 0) { int k, kase; // Here is where a test for too many iterations would go. // This section of the program inspects for // negligible elements in the s and e arrays. On // completion the variables kase and k are set as follows. // kase = 1 if s(p) and e[k-1] are negligible and k<p // kase = 2 if s(k) is negligible and k<p // kase = 3 if e[k-1] is negligible, k<p, and // s(k), ..., s(p) are not negligible (qr step). // kase = 4 if e(p-1) is negligible (convergence). for (k = p - 2; k >= -1; k--) { if (k == -1) { break; } if (Math.Abs(e[k]) <= tiny + eps * (Math.Abs(s[k]) + Math.Abs(s[k + 1]))) { e[k] = 0.0; break; } } if (k == p - 2) { kase = 4; } else { int ks; for (ks = p - 1; ks >= k; ks--) { if (ks == k) { break; } double t = (ks != p ? Math.Abs(e[ks]) : 0.0) + (ks != k + 1 ? Math.Abs(e[ks - 1]) : 0.0); if (Math.Abs(s[ks]) <= tiny + eps * t) { s[ks] = 0.0; break; } } if (ks == k) { kase = 3; } else if (ks == p - 1) { kase = 1; } else { kase = 2; k = ks; } } k++; // Perform the task indicated by kase. switch (kase) { // Deflate negligible s(p). case 1: { double f = e[p - 2]; e[p - 2] = 0.0; for (int j = p - 2; j >= k; j--) { double t = EncogMath.Hypot(s[j], f); double cs = s[j] / t; double sn = f / t; s[j] = t; if (j != k) { f = -sn * e[j - 1]; e[j - 1] = cs * e[j - 1]; } if (wantv) { for (int i = 0; i < n; i++) { t = cs * vmatrix[i][j] + sn * vmatrix[i][p - 1]; vmatrix[i][p - 1] = -sn * vmatrix[i][j] + cs * vmatrix[i][p - 1]; vmatrix[i][j] = t; } } } } break; // Split at negligible s(k). case 2: { double f = e[k - 1]; e[k - 1] = 0.0; for (int j = k; j < p; j++) { double t = EncogMath.Hypot(s[j], f); double cs = s[j] / t; double sn = f / t; s[j] = t; f = -sn * e[j]; e[j] = cs * e[j]; if (wantu) { for (int i = 0; i < m; i++) { t = cs * umatrix[i][j] + sn * umatrix[i][k - 1]; umatrix[i][k - 1] = -sn * umatrix[i][j] + cs * umatrix[i][k - 1]; umatrix[i][j] = t; } } } } break; // Perform one qr step. case 3: { // Calculate the shift. double scale = Math.Max(Math.Max(Math .Max(Math.Max(Math.Abs(s[p - 1]), Math.Abs(s[p - 2])), Math.Abs(e[p - 2])), Math.Abs(s[k])), Math .Abs( e[k])); double sp = s[p - 1] / scale; double spm1 = s[p - 2] / scale; double epm1 = e[p - 2] / scale; double sk = s[k] / scale; double ek = e[k] / scale; double b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2.0; double c = (sp * epm1) * (sp * epm1); double shift = 0.0; if ((b != 0.0) | (c != 0.0)) { shift = Math.Sqrt(b * b + c); if (b < 0.0) { shift = -shift; } shift = c / (b + shift); } double f = (sk + sp) * (sk - sp) + shift; double g = sk * ek; // Chase zeros. for (int j = k; j < p - 1; j++) { double t = EncogMath.Hypot(f, g); double cs = f / t; double sn = g / t; if (j != k) { e[j - 1] = t; } f = cs * s[j] + sn * e[j]; e[j] = cs * e[j] - sn * s[j]; g = sn * s[j + 1]; s[j + 1] = cs * s[j + 1]; if (wantv) { for (int i = 0; i < n; i++) { t = cs * vmatrix[i][j] + sn * vmatrix[i][j + 1]; vmatrix[i][j + 1] = -sn * vmatrix[i][j] + cs * vmatrix[i][j + 1]; vmatrix[i][j] = t; } } t = EncogMath.Hypot(f, g); cs = f / t; sn = g / t; s[j] = t; f = cs * e[j] + sn * s[j + 1]; s[j + 1] = -sn * e[j] + cs * s[j + 1]; g = sn * e[j + 1]; e[j + 1] = cs * e[j + 1]; if (wantu && (j < m - 1)) { for (int i = 0; i < m; i++) { t = cs * umatrix[i][j] + sn * umatrix[i][j + 1]; umatrix[i][j + 1] = -sn * umatrix[i][j] + cs * umatrix[i][j + 1]; umatrix[i][j] = t; } } } e[p - 2] = f; iter = iter + 1; } break; // Convergence. case 4: { // Make the singular values positive. if (s[k] <= 0.0) { s[k] = (s[k] < 0.0 ? -s[k] : 0.0); if (wantv) { for (int i = 0; i <= pp; i++) { vmatrix[i][k] = -vmatrix[i][k]; } } } // Order the singular values. while (k < pp) { if (s[k] >= s[k + 1]) { break; } double t = s[k]; s[k] = s[k + 1]; s[k + 1] = t; if (wantv && (k < n - 1)) { for (int i = 0; i < n; i++) { t = vmatrix[i][k + 1]; vmatrix[i][k + 1] = vmatrix[i][k]; vmatrix[i][k] = t; } } if (wantu && (k < m - 1)) { for (int i = 0; i < m; i++) { t = umatrix[i][k + 1]; umatrix[i][k + 1] = umatrix[i][k]; umatrix[i][k] = t; } } k++; } iter = 0; p--; } break; } } }
/// <inheritdoc /> protected override void LearnConnection(IFreeformConnection connection) { // multiply the current and previous gradient, and take the // sign. We want to see if the gradient has changed its sign. int change = EncogMath .Sign(connection .GetTempTraining(TempGradient) * connection .GetTempTraining(TempLastGradient)); double weightChange = 0; // if the gradient has retained its sign, then we increase the // delta so that it will converge faster if (change > 0) { double delta = connection .GetTempTraining(TempUpdate) * RPROPConst.PositiveEta; delta = Math.Min(delta, _maxStep); weightChange = EncogMath .Sign(connection .GetTempTraining(TempGradient)) * delta; connection.SetTempTraining( TempUpdate, delta); connection .SetTempTraining( TempLastGradient, connection .GetTempTraining(TempGradient)); } else if (change < 0) { // if change<0, then the sign has changed, and the last // delta was too big double delta = connection .GetTempTraining(TempUpdate) * RPROPConst.NegativeEta; delta = Math.Max(delta, RPROPConst.DeltaMin); connection.SetTempTraining( TempUpdate, delta); weightChange = -connection .GetTempTraining(TempLastWeightDelta); // set the previous gradient to zero so that there will be no // adjustment the next iteration connection.SetTempTraining( TempLastGradient, 0); } else if (change == 0) { // if change==0 then there is no change to the delta double delta = connection .GetTempTraining(TempUpdate); weightChange = EncogMath .Sign(connection .GetTempTraining(TempGradient)) * delta; connection .SetTempTraining( TempLastGradient, connection .GetTempTraining(TempGradient)); } // apply the weight change, if any connection.Weight += weightChange; connection.SetTempTraining( TempLastWeightDelta, weightChange); }
/// <summary> /// Symmetric tridiagonal QL algorithm. /// </summary> private void Tql2() { // This is derived from the Algol procedures tql2, by // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. for (int i = 1; i < n; i++) { e[i - 1] = e[i]; } e[n - 1] = 0.0; double f = 0.0; double tst1 = 0.0; double eps = Math.Pow(2.0, -52.0); for (int l = 0; l < n; l++) { // Find small subdiagonal element tst1 = Math.Max(tst1, Math.Abs(d[l]) + Math.Abs(e[l])); int m = l; while (m < n) { if (Math.Abs(e[m]) <= eps * tst1) { break; } m++; } // If m == l, d[l] is an eigenvalue, // otherwise, iterate. if (m > l) { int iter = 0; do { iter = iter + 1; // (Could check iteration count here.) // Compute implicit shift double g = d[l]; double p = (d[l + 1] - g) / (2.0 * e[l]); double r = EncogMath.Hypot(p, 1.0); if (p < 0) { r = -r; } d[l] = e[l] / (p + r); d[l + 1] = e[l] * (p + r); double dl1 = d[l + 1]; double h = g - d[l]; for (int i = l + 2; i < n; i++) { d[i] -= h; } f = f + h; // Implicit QL transformation. p = d[m]; double c = 1.0; double c2 = c; double c3 = c; double el1 = e[l + 1]; double s = 0.0; double s2 = 0.0; for (int i = m - 1; i >= l; i--) { c3 = c2; c2 = c; s2 = s; g = c * e[i]; h = c * p; r = EncogMath.Hypot(p, e[i]); e[i + 1] = s * r; s = e[i] / r; c = p / r; p = c * d[i] - s * g; d[i + 1] = h + s * (c * g + s * d[i]); // Accumulate transformation. for (int k = 0; k < n; k++) { h = v[k][i + 1]; v[k][i + 1] = s * v[k][i] + c * h; v[k][i] = c * v[k][i] - s * h; } } p = -s * s2 * c3 * el1 * e[l] / dl1; e[l] = s * p; d[l] = c * p; // Check for convergence. } while (Math.Abs(e[l]) > eps * tst1); } d[l] = d[l] + f; e[l] = 0.0; } // Sort eigenvalues and corresponding vectors. for (int i = 0; i < n - 1; i++) { int k = i; double p = d[i]; for (int j = i + 1; j < n; j++) { if (d[j] < p) { k = j; p = d[j]; } } if (k != i) { d[k] = d[i]; d[i] = p; for (int j = 0; j < n; j++) { p = v[j][i]; v[j][i] = v[j][k]; v[j][k] = p; } } } }