public RBFNetwork(int inputCount, int hiddenCount, int outputCount, RBFEnum t) { if (hiddenCount != 0) { IRadialBasisFunction[] rbf = new IRadialBasisFunction[hiddenCount]; double volumeNeuronRBFWidth = 2.0 / ((double) hiddenCount); this._flat = new FlatNetworkRBF(inputCount, rbf.Length, outputCount, rbf); try { this.SetRBFCentersAndWidthsEqualSpacing(-1.0, 1.0, t, volumeNeuronRBFWidth, false); } catch (EncogError) { this.RandomizeRBFCentersAndWidths(-1.0, 1.0, t); } } else { do { throw new NeuralNetworkError("RBF network cannot have zero hidden neurons."); } while ((((uint) outputCount) | 2) == 0); } }
/// <summary> /// Construct a multi-dimensional neighborhood function. /// </summary> /// <param name="size">The sizes of each dimension.</param> /// <param name="type">The RBF type to use.</param> public NeighborhoodRBF(int[] size, RBFEnum type) { _params = new double[size.Length]; switch (type) { case RBFEnum.Gaussian: _rbf = new GaussianFunction(size.Length, _params, 0); break; case RBFEnum.InverseMultiquadric: _rbf = new InverseMultiquadricFunction(size.Length, _params, 0); break; case RBFEnum.Multiquadric: _rbf = new MultiquadricFunction(size.Length, _params, 0); break; case RBFEnum.MexicanHat: _rbf = new MexicanHatFunction(size.Length, _params, 0); break; } _size = size; CalculateDisplacement(); }
/// <summary> /// Construct a 1d neighborhood function. /// </summary> /// <param name="type">The RBF type to use.</param> public NeighborhoodRBF1D(RBFEnum type) { switch (type) { case RBFEnum.Gaussian: _radial = new GaussianFunction(1, _params, 0); break; case RBFEnum.InverseMultiquadric: _radial = new InverseMultiquadricFunction(1, _params, 0); break; case RBFEnum.Multiquadric: _radial = new MultiquadricFunction(1, _params, 0); break; case RBFEnum.MexicanHat: _radial = new MexicanHatFunction(1, _params, 0); break; default: throw new AIFHError("Unknown RBF type: " + type.ToString()); } _radial.Width = 1.0; }
/// <summary> /// Construct the object. /// </summary> public RadialBasisPattern() { _rbfType = RBFEnum.Gaussian; _inputNeurons = -1; _outputNeurons = -1; _hiddenNeurons = -1; }
/// <summary> /// Construct RBF network. /// </summary> /// /// <param name="inputCount">The input count.</param> /// <param name="hiddenCount">The hidden count.</param> /// <param name="outputCount">The output count.</param> /// <param name="t">The RBF type.</param> public RBFNetwork(int inputCount, int hiddenCount, int outputCount, RBFEnum t) { if (hiddenCount == 0) { throw new NeuralNetworkError( "RBF network cannot have zero hidden neurons."); } var rbf = new IRadialBasisFunction[hiddenCount]; // Set the standard RBF neuron width. // Literature seems to suggest this is a good default value. double volumeNeuronWidth = 2.0d / hiddenCount; _flat = new FlatNetworkRBF(inputCount, rbf.Length, outputCount, rbf); try { // try this SetRBFCentersAndWidthsEqualSpacing(-1, 1, t, volumeNeuronWidth, false); } catch (EncogError) { // if we have the wrong number of hidden neurons, try this RandomizeRBFCentersAndWidths(-1, 1, t); } }
public NeighborhoodRBF(int[] size, RBFEnum type) { if (-1 != 0) { RBFEnum enum2 = type; if (-2147483648 != 0) { switch (enum2) { case RBFEnum.Gaussian: this._x542ac40d5d0f20b7 = new GaussianFunction(2); break; case RBFEnum.Multiquadric: this._x542ac40d5d0f20b7 = new MultiquadricFunction(2); break; case RBFEnum.InverseMultiquadric: this._x542ac40d5d0f20b7 = new InverseMultiquadricFunction(2); break; case RBFEnum.MexicanHat: this._x542ac40d5d0f20b7 = new MexicanHatFunction(2); break; } } } this._x0ceec69a97f73617 = size; this.x2d3eee42a645354a(); }
/// <summary> /// Construct a 1d neighborhood function. /// </summary> /// /// <param name="type">The RBF type to use.</param> public NeighborhoodRBF1D(RBFEnum type) { switch (type) { case RBFEnum.Gaussian: _radial = new GaussianFunction(1); break; case RBFEnum.InverseMultiquadric: _radial = new InverseMultiquadricFunction(1); break; case RBFEnum.Multiquadric: _radial = new MultiquadricFunction(1); break; case RBFEnum.MexicanHat: _radial = new MexicanHatFunction(1); break; default: throw new NeuralNetworkError("Unknown RBF type: " + type); } _radial.Width = 1.0d; }
/// <summary> /// Specify specific centers and widths for the provided RBFType /// </summary> /// <param name="centers">Array containing center position. Row n contains centers for neuron n. Row n contains x elements for x number of dimensions.</param> /// <param name="widths">Array containing widths. Row n contains widths for neuron n. Row n contains x elements for x number of dimensions.</param> /// <param name="RBFType">The RBF Function to use for this layer.</param> public void SetRBFCentersAndWidths(double[][] centers, double[] widths, RBFEnum RBFType) { for (int i = 0; i < this.NeuronCount; i++) { SetRBFFunction(i, RBFType, centers[i], widths[i]); } }
public NeighborhoodRBF1D(RBFEnum type) { switch (type) { case RBFEnum.Gaussian: this._x69265a675586f26d = new GaussianFunction(1); break; case RBFEnum.Multiquadric: this._x69265a675586f26d = new MultiquadricFunction(1); break; case RBFEnum.InverseMultiquadric: this._x69265a675586f26d = new InverseMultiquadricFunction(1); if (1 == 0) { goto Label_0032; } break; case RBFEnum.MexicanHat: this._x69265a675586f26d = new MexicanHatFunction(1); break; default: throw new NeuralNetworkError("Unknown RBF type: " + type); } Label_001E: this._x69265a675586f26d.Width = 1.0; Label_0032: if (-1 == 0) { goto Label_001E; } }
/// <summary> /// Construct a 2d neighborhood function based on the sizes for the /// x and y dimensions. /// </summary> /// <param name="type">The RBF type to use.</param> /// <param name="x">The size of the x-dimension.</param> /// <param name="y">The size of the y-dimension.</param> public NeighborhoodRBF(RBFEnum type, int x, int y) { var size = new int[2]; size[0] = x; size[1] = y; _params = new double[3]; switch (type) { case RBFEnum.Gaussian: _rbf = new GaussianFunction(2, _params, 0); break; case RBFEnum.InverseMultiquadric: _rbf = new InverseMultiquadricFunction(2, _params, 0); break; case RBFEnum.Multiquadric: _rbf = new MultiquadricFunction(2, _params, 0); break; case RBFEnum.MexicanHat: _rbf = new MexicanHatFunction(2, _params, 0); break; } _rbf.Width = 1; _size = size; CalculateDisplacement(); }
/// <summary> /// Construct RBF network. /// </summary> /// /// <param name="inputCount">The input count.</param> /// <param name="hiddenCount">The hidden count.</param> /// <param name="outputCount">The output count.</param> /// <param name="t">The RBF type.</param> public RBFNetwork(int inputCount, int hiddenCount, int outputCount, RBFEnum t) { if (hiddenCount == 0) { throw new NeuralNetworkError( "RBF network cannot have zero hidden neurons."); } var rbf = new IRadialBasisFunction[hiddenCount]; // Set the standard RBF neuron width. // Literature seems to suggest this is a good default value. double volumeNeuronWidth = 2.0d/hiddenCount; _flat = new FlatNetworkRBF(inputCount, rbf.Length, outputCount, rbf); try { // try this SetRBFCentersAndWidthsEqualSpacing(-1, 1, t, volumeNeuronWidth, false); } catch (EncogError) { // if we have the wrong number of hidden neurons, try this RandomizeRBFCentersAndWidths(-1, 1, t); } }
/// <summary> /// Array containing center position. Row n contains centers for neuron n. /// Row n contains x elements for x number of dimensions. /// </summary> /// /// <param name="centers">The centers.</param> /// <param name="widths"></param> /// <param name="t">The RBF Function to use for this layer.</param> public void SetRBFCentersAndWidths(double[][] centers, double[] widths, RBFEnum t) { for (int i = 0; i < _flat.RBF.Length; i++) { SetRBFFunction(i, t, centers[i], widths[i]); } }
private void SetRBFFunction(int RBFIndex, RBFEnum RBFType, double[] centers, double width) { if (RBFType == RBFEnum.Gaussian) { this.radialBasisFunction[RBFIndex] = new GaussianFunction(0.5, centers, width); } else if (RBFType == RBFEnum.Multiquadric) { this.radialBasisFunction[RBFIndex] = new MultiquadricFunction(0.5, centers, width); } else if (RBFType == RBFEnum.InverseMultiquadric) { this.radialBasisFunction[RBFIndex] = new InverseMultiquadricFunction(0.5, centers, width); } }
/// <summary> /// Set the RBF components to random values. /// </summary> /// /// <param name="min">Minimum random value.</param> /// <param name="max">Max random value.</param> /// <param name="t">The type of RBF to use.</param> public void RandomizeRBFCentersAndWidths(double min, double max, RBFEnum t) { int dimensions = InputCount; var centers = new double[dimensions]; for (int i = 0; i < dimensions; i++) { centers[i] = RangeRandomizer.Randomize(min, max); } for (int i = 0; i < _flat.RBF.Length; i++) { SetRBFFunction(i, t, centers, RangeRandomizer.Randomize(min, max)); } }
/// <summary> /// Construct a 2d neighborhood function based on the sizes for the /// x and y dimensions. /// </summary> /// /// <param name="type">The RBF type to use.</param> /// <param name="x">The size of the x-dimension.</param> /// <param name="y">The size of the y-dimension.</param> public NeighborhoodRBF(RBFEnum type, int x, int y) { var size = new int[2]; size[0] = x; size[1] = y; var centerArray = new double[2]; centerArray[0] = 0; centerArray[1] = 0; var widthArray = new double[2]; widthArray[0] = 1; widthArray[1] = 1; switch (type) { case RBFEnum.Gaussian: _rbf = new GaussianFunction(2); break; case RBFEnum.InverseMultiquadric: _rbf = new InverseMultiquadricFunction(2); break; case RBFEnum.Multiquadric: _rbf = new MultiquadricFunction(2); break; case RBFEnum.MexicanHat: _rbf = new MexicanHatFunction(2); break; } _rbf.Width = 1; EngineArray.ArrayCopy(centerArray, _rbf.Centers); _size = size; CalculateDisplacement(); }
/// <summary> /// Set an RBF function. /// </summary> /// /// <param name="index">The index to set.</param> /// <param name="t">The function type.</param> /// <param name="centers">The centers.</param> /// <param name="width">The width.</param> public void SetRBFFunction(int index, RBFEnum t, double[] centers, double width) { if (t == RBFEnum.Gaussian) { _flat.RBF[index] = new GaussianFunction(0.5d, centers, width); } else if (t == RBFEnum.Multiquadric) { _flat.RBF[index] = new MultiquadricFunction(0.5d, centers, width); } else if (t == RBFEnum.InverseMultiquadric) { _flat.RBF[index] = new InverseMultiquadricFunction(0.5d, centers, width); } }
/// <summary> /// Construct a 2d neighborhood function based on the sizes for the /// x and y dimensions. /// </summary> /// <param name="type">The RBF type to use.</param> /// <param name="x">The size of the x-dimension.</param> /// <param name="y">The size of the y-dimension.</param> public NeighborhoodRBF(RBFEnum type, int x, int y) { int[] size = new int[2]; size[0] = x; size[1] = y; double[] centerArray = new double[2]; centerArray[0] = 0; centerArray[1] = 0; double[] widthArray = new double[2]; widthArray[0] = 1; widthArray[1] = 1; switch (type) { case RBFEnum.Gaussian: this.rbf = new GaussianFunction(2); break; case RBFEnum.InverseMultiquadric: this.rbf = new InverseMultiquadricFunction(2); break; case RBFEnum.Multiquadric: this.rbf = new MultiquadricFunction(2); break; case RBFEnum.MexicanHat: this.rbf = new MexicanHatFunction(2); break; } this.rbf.Width = 1; EngineArray.ArrayCopy(centerArray, this.rbf.Centers); this.size = size; CalculateDisplacement(); }
/// <summary> /// Set the gausian components to random values. /// </summary> /// <param name="dimensions">The number of dimensions in the network.</param> /// <param name="min">The minimum value for the centers, widths and peaks.</param> /// <param name="max">The maximum value for the centers, widths and peaks.</param> /// <param name="t">The RBF to use.</param> public void RandomizeRBFCentersAndWidths(int dimensions, double min, double max, RBFEnum t) { double[] centers = new double[dimensions]; for (int i = 0; i < dimensions; i++) { centers[i] = RangeRandomizer.Randomize(min, max); } for (int i = 0; i < this.NeuronCount; i++) { SetRBFFunction(i, t, centers, RangeRandomizer.Randomize(min, max)); } }
/// <summary> /// Equally spaces all hidden neurons within the n dimensional variable space. /// </summary> /// <param name="minPosition">The minimum position neurons should be centered. Typically 0.</param> /// <param name="maxPosition">The maximum position neurons should be centered. Typically 1</param> /// <param name="RBFType">The RBF type to use.</param> /// <param name="dimensions">The number of dimensions.</param> /// <param name="volumeNeuronRBFWidth">The neuron width of neurons within the mesh.</param> /// <param name="useWideEdgeRBFs">Enables wider RBF's around the boundary of the neuron mesh.</param> public void SetRBFCentersAndWidthsEqualSpacing(double minPosition, double maxPosition, RBFEnum RBFType, int dimensions, double volumeNeuronRBFWidth, bool useWideEdgeRBFs) { int totalNumHiddenNeurons = NeuronCount; double disMinMaxPosition = Math.Abs(maxPosition - minPosition); //Check to make sure we have the correct number of neurons for the provided dimensions int expectedSideLength = (int)Math.Pow(totalNumHiddenNeurons, 1.0 / dimensions); if ((double)expectedSideLength != Math.Pow(totalNumHiddenNeurons, 1.0 / dimensions)) { throw new Exception("Total number of RBF neurons must be some integer to the power of 'dimensions'."); } double edgeNeuronRBFWidth = 2.5 * volumeNeuronRBFWidth; double[][] centers = new double[totalNumHiddenNeurons][]; double[] widths = new double[totalNumHiddenNeurons]; #region buildCentersAndWidths Volume Neurons for (int i = 0; i < totalNumHiddenNeurons; i++) { centers[i] = new double[dimensions]; int sideLength = expectedSideLength; //Evenly distribute the volume neurons. int temp = i; //First determine the centers for (int j = dimensions; j > 0; j--) { //i + j * sidelength + k * sidelength ^2 + ... l * sidelength ^ n //i - neuron number in x direction, i.e. 0,1,2,3 //j - neuron number in y direction, i.e. 0,1,2,3 //Following example assumes sidelength of 4 //e.g Neuron 5 - x position is (int)5/4 * 0.33 = 0.33 //then take modulus of 5%4 = 1 //Neuron 5 - y position is (int)1/1 * 0.33 = 0.33 centers[i][j - 1] = ((int)(temp / Math.Pow(sideLength, j - 1)) * (disMinMaxPosition / (sideLength - 1))) + minPosition; temp = temp % (int)(Math.Pow(sideLength, j - 1)); } //Now set the widths if ((centers[i].Contains(1) || centers[i].Contains(0)) && useWideEdgeRBFs) { widths[i] = edgeNeuronRBFWidth; } else { widths[i] = volumeNeuronRBFWidth; } //centers[i] = (double)(1 / (double)(neuronCount - 1)) * (double)i; } #endregion SetRBFCentersAndWidths(centers, widths, RBFType); //SaveOutNeuronCentersAndWeights(centers, widths); }
public void RandomizeRBFCentersAndWidths(double min, double max, RBFEnum t) { int num2; int num3; int inputCount = this.InputCount; double[] centers = new double[inputCount]; if ((((uint) inputCount) & 0) == 0) { num2 = 0; goto Label_004D; } Label_0037: while (num3 < this._flat.RBF.Length) { this.SetRBFFunction(num3, t, centers, RangeRandomizer.Randomize(min, max)); num3++; if ((((uint) num3) - ((uint) num3)) > uint.MaxValue) { return; } } return; Label_004D: if (num2 < inputCount) { centers[num2] = RangeRandomizer.Randomize(min, max); } else { num3 = 0; goto Label_0037; } num2++; goto Label_004D; }
public void SetRBFCentersAndWidthsEqualSpacing(double minPosition, double maxPosition, RBFEnum t, double volumeNeuronRBFWidth, bool useWideEdgeRBFs) { int num2; double num3; int num4; double num5; double num6; double[][] numArray; double[] numArray2; int num7; int num8; int num9; int num10; int num11; int length = this._flat.RBF.Length; goto Label_0257; Label_0013: num7++; Label_0019: if (num7 < length) { numArray[num7] = new double[num2]; if (((uint) num8) >= 0) { num8 = num4; num9 = num7; goto Label_019F; } goto Label_012A; } this.SetRBFCentersAndWidths(numArray, numArray2, t); return; Label_003B: if ((((uint) volumeNeuronRBFWidth) | 8) == 0) { goto Label_019F; } if ((((uint) maxPosition) & 0) == 0) { goto Label_0013; } return; Label_012A: if (num10 <= 0) { bool flag = false; if ((((uint) num5) + ((uint) num6)) >= 0) { num11 = 0; while (true) { if (num11 < numArray[0].Length) { if ((numArray[num7][num11] == 1.0) || (numArray[num7][num11] == 0.0)) { flag = true; } num11++; } else if (flag && useWideEdgeRBFs) { numArray2[num7] = num6; if (((uint) num8) > uint.MaxValue) { goto Label_015C; } if (0 != 0) { goto Label_003B; } if ((((uint) num11) & 0) == 0) { if ((((uint) useWideEdgeRBFs) + ((uint) maxPosition)) >= 0) { goto Label_0013; } goto Label_0257; } } else { numArray2[num7] = volumeNeuronRBFWidth; goto Label_003B; } if ((((uint) num9) + ((uint) maxPosition)) < 0) { goto Label_0183; } } } goto Label_0230; } Label_015C: numArray[num7][num10 - 1] = (((int) (((double) num9) / Math.Pow((double) num8, (double) (num10 - 1)))) * (num3 / ((double) (num8 - 1)))) + minPosition; Label_0183: num9 = num9 % ((int) Math.Pow((double) num8, (double) (num10 - 1))); goto Label_01BA; Label_019F: num10 = num2; if ((((uint) num4) + ((uint) useWideEdgeRBFs)) <= uint.MaxValue) { goto Label_012A; } Label_01BA: if (((uint) num11) >= 0) { num10--; } goto Label_012A; Label_0230: if (num4 != num5) { throw new NeuralNetworkError("Total number of RBF neurons must be some integer to the power of 'dimensions'.\n" + Format.FormatDouble((double) num4, 5) + " <> " + Format.FormatDouble(num5, 5)); } num6 = 2.5 * volumeNeuronRBFWidth; numArray = new double[length][]; numArray2 = new double[length]; num7 = 0; goto Label_0019; Label_0257: num2 = this.InputCount; num3 = Math.Abs((double) (maxPosition - minPosition)); num4 = (int) Math.Pow((double) length, 1.0 / ((double) num2)); num5 = Math.Pow((double) length, 1.0 / ((double) num2)); goto Label_0230; }
/// <summary> /// Equally spaces all hidden neurons within the n dimensional variable /// space. /// </summary> /// /// <param name="minPosition">The minimum position neurons should be centered. Typically 0.</param> /// <param name="maxPosition">The maximum position neurons should be centered. Typically 1</param> /// <param name="t">The RBF type.</param> /// <param name="volumeNeuronRBFWidth">The neuron width of neurons within the mesh.</param> /// <param name="useWideEdgeRBFs">Enables wider RBF's around the boundary of the neuron mesh.</param> public void SetRBFCentersAndWidthsEqualSpacing( double minPosition, double maxPosition, RBFEnum t, double volumeNeuronRBFWidth, bool useWideEdgeRBFs) { int totalNumHiddenNeurons = _flat.RBF.Length; int dimensions = InputCount; double disMinMaxPosition = Math.Abs(maxPosition - minPosition); // Check to make sure we have the correct number of neurons for the // provided dimensions var expectedSideLength = (int)Math.Pow(totalNumHiddenNeurons, 1.0d / dimensions); double cmp = Math.Pow(totalNumHiddenNeurons, 1.0d / dimensions); if (expectedSideLength != cmp) { throw new NeuralNetworkError( "Total number of RBF neurons must be some integer to the power of 'dimensions'.\n" + Format.FormatDouble(expectedSideLength, 5) + " <> " + Format.FormatDouble(cmp, 5)); } double edgeNeuronRBFWidth = 2.5d * volumeNeuronRBFWidth; var centers = new double[totalNumHiddenNeurons][]; var widths = new double[totalNumHiddenNeurons]; for (int i = 0; i < totalNumHiddenNeurons; i++) { centers[i] = new double[dimensions]; int sideLength = expectedSideLength; // Evenly distribute the volume neurons. int temp = i; // First determine the centers for (int j = dimensions; j > 0; j--) { // i + j * sidelength + k * sidelength ^2 + ... l * sidelength ^ // n // i - neuron number in x direction, i.e. 0,1,2,3 // j - neuron number in y direction, i.e. 0,1,2,3 // Following example assumes sidelength of 4 // e.g Neuron 5 - x position is (int)5/4 * 0.33 = 0.33 // then take modulus of 5%4 = 1 // Neuron 5 - y position is (int)1/1 * 0.33 = 0.33 centers[i][j - 1] = ((int)(temp / Math.Pow(sideLength, j - 1)) * (disMinMaxPosition / (sideLength - 1))) + minPosition; temp = temp % (int)(Math.Pow(sideLength, j - 1)); } // Now set the widths bool contains = false; for (int z = 0; z < centers[0].Length; z++) { if ((centers[i][z] == 1.0d) || (centers[i][z] == 0.0d)) { contains = true; } } if (contains && useWideEdgeRBFs) { widths[i] = edgeNeuronRBFWidth; } else { widths[i] = volumeNeuronRBFWidth; } } SetRBFCentersAndWidths(centers, widths, t); }
public void SetRBFFunction(int index, RBFEnum t, double[] centers, double width) { if (t == RBFEnum.Gaussian) { this._flat.RBF[index] = new GaussianFunction(0.5, centers, width); } else { if (t == RBFEnum.Multiquadric) { this._flat.RBF[index] = new MultiquadricFunction(0.5, centers, width); if (-2 != 0) { return; } } else if (t != RBFEnum.InverseMultiquadric) { return; } this._flat.RBF[index] = new InverseMultiquadricFunction(0.5, centers, width); } }
public NeighborhoodRBF(RBFEnum type, int x, int y) { int[] numArray; double[] numArray2; goto Label_0152; Label_000B: EngineArray.ArrayCopy(numArray2, this._x542ac40d5d0f20b7.Centers); this._x0ceec69a97f73617 = numArray; if (((uint) y) > uint.MaxValue) { goto Label_0122; } this.x2d3eee42a645354a(); if ((((uint) y) + ((uint) y)) > uint.MaxValue) { goto Label_00EB; } if (-2 != 0) { return; } goto Label_0152; Label_0068: this._x542ac40d5d0f20b7.Width = 1.0; Label_00E4: if (8 != 0) { if (0 == 0) { goto Label_000B; } goto Label_0129; } Label_00EB: numArray2[0] = 0.0; numArray2[1] = 0.0; double[] numArray3 = new double[] { 1.0, 1.0 }; Label_0122: switch (type) { case RBFEnum.Gaussian: this._x542ac40d5d0f20b7 = new GaussianFunction(2); goto Label_0068; case RBFEnum.Multiquadric: this._x542ac40d5d0f20b7 = new MultiquadricFunction(2); goto Label_0068; case RBFEnum.InverseMultiquadric: this._x542ac40d5d0f20b7 = new InverseMultiquadricFunction(2); goto Label_0068; case RBFEnum.MexicanHat: this._x542ac40d5d0f20b7 = new MexicanHatFunction(2); if (((0 == 0) && (-1 != 0)) && (0 != 0)) { goto Label_00E4; } goto Label_0068; default: goto Label_0068; } Label_0129: numArray[0] = x; numArray[1] = y; numArray2 = new double[2]; if ((((uint) y) - ((uint) y)) <= uint.MaxValue) { goto Label_00EB; } goto Label_000B; Label_0152: if ((((uint) x) - ((uint) x)) < 0) { goto Label_0068; } numArray = new int[2]; goto Label_0129; }
private void SetRBFFunction(int RBFIndex, RBFEnum RBFType, double[] centers, double width) { if (RBFType == RBFEnum.Gaussian) this.radialBasisFunction[RBFIndex] = new GaussianFunction(0.5, centers, width); else if (RBFType == RBFEnum.Multiquadric) this.radialBasisFunction[RBFIndex] = new MultiquadricFunction(0.5, centers, width); else if (RBFType == RBFEnum.InverseMultiquadric) this.radialBasisFunction[RBFIndex] = new InverseMultiquadricFunction(0.5, centers, width); }
/// <summary> /// Equally spaces all hidden neurons within the n dimensional variable /// space. /// </summary> /// /// <param name="minPosition">The minimum position neurons should be centered. Typically 0.</param> /// <param name="maxPosition">The maximum position neurons should be centered. Typically 1</param> /// <param name="t">The RBF type.</param> /// <param name="volumeNeuronRBFWidth">The neuron width of neurons within the mesh.</param> /// <param name="useWideEdgeRBFs">Enables wider RBF's around the boundary of the neuron mesh.</param> public void SetRBFCentersAndWidthsEqualSpacing( double minPosition, double maxPosition, RBFEnum t, double volumeNeuronRBFWidth, bool useWideEdgeRBFs) { int totalNumHiddenNeurons = _flat.RBF.Length; int dimensions = InputCount; double disMinMaxPosition = Math.Abs(maxPosition - minPosition); // Check to make sure we have the correct number of neurons for the // provided dimensions var expectedSideLength = (int) Math.Pow(totalNumHiddenNeurons, 1.0d/dimensions); double cmp = Math.Pow(totalNumHiddenNeurons, 1.0d/dimensions); if (expectedSideLength != cmp) { throw new NeuralNetworkError( "Total number of RBF neurons must be some integer to the power of 'dimensions'.\n" + Format.FormatDouble(expectedSideLength, 5) + " <> " + Format.FormatDouble(cmp, 5)); } double edgeNeuronRBFWidth = 2.5d*volumeNeuronRBFWidth; var centers = new double[totalNumHiddenNeurons][]; var widths = new double[totalNumHiddenNeurons]; for (int i = 0; i < totalNumHiddenNeurons; i++) { centers[i] = new double[dimensions]; int sideLength = expectedSideLength; // Evenly distribute the volume neurons. int temp = i; // First determine the centers for (int j = dimensions; j > 0; j--) { // i + j * sidelength + k * sidelength ^2 + ... l * sidelength ^ // n // i - neuron number in x direction, i.e. 0,1,2,3 // j - neuron number in y direction, i.e. 0,1,2,3 // Following example assumes sidelength of 4 // e.g Neuron 5 - x position is (int)5/4 * 0.33 = 0.33 // then take modulus of 5%4 = 1 // Neuron 5 - y position is (int)1/1 * 0.33 = 0.33 centers[i][j - 1] = ((int) (temp/Math.Pow(sideLength, j - 1))*(disMinMaxPosition/(sideLength - 1))) + minPosition; temp = temp%(int) (Math.Pow(sideLength, j - 1)); } // Now set the widths bool contains = false; for (int z = 0; z < centers[0].Length; z++) { if ((centers[i][z] == 1.0d) || (centers[i][z] == 0.0d)) { contains = true; } } if (contains && useWideEdgeRBFs) { widths[i] = edgeNeuronRBFWidth; } else { widths[i] = volumeNeuronRBFWidth; } } SetRBFCentersAndWidths(centers, widths, t); }
/// <summary> /// Equally spaces all hidden neurons within the n dimensional variable space. /// </summary> /// <param name="minPosition">The minimum position neurons should be centered. Typically 0.</param> /// <param name="maxPosition">The maximum position neurons should be centered. Typically 1</param> /// <param name="RBFType">The RBF type to use.</param> /// <param name="dimensions">The number of dimensions.</param> /// <param name="volumeNeuronRBFWidth">The neuron width of neurons within the mesh.</param> /// <param name="useWideEdgeRBFs">Enables wider RBF's around the boundary of the neuron mesh.</param> public void SetRBFCentersAndWidthsEqualSpacing(double minPosition, double maxPosition, RBFEnum RBFType, int dimensions, double volumeNeuronRBFWidth, bool useWideEdgeRBFs) { int totalNumHiddenNeurons = NeuronCount; double disMinMaxPosition = Math.Abs(maxPosition - minPosition); //Check to make sure we have the correct number of neurons for the provided dimensions int expectedSideLength = (int)Math.Pow(totalNumHiddenNeurons, 1.0 / dimensions); if ((double)expectedSideLength != Math.Pow(totalNumHiddenNeurons, 1.0 / dimensions)) throw new Exception("Total number of RBF neurons must be some integer to the power of 'dimensions'."); double edgeNeuronRBFWidth = 2.5 * volumeNeuronRBFWidth; double[][] centers = new double[totalNumHiddenNeurons][]; double[] widths = new double[totalNumHiddenNeurons]; #region buildCentersAndWidths Volume Neurons for (int i = 0; i < totalNumHiddenNeurons; i++) { centers[i] = new double[dimensions]; int sideLength = expectedSideLength; //Evenly distribute the volume neurons. int temp = i; //First determine the centers for (int j = dimensions; j > 0; j--) { //i + j * sidelength + k * sidelength ^2 + ... l * sidelength ^ n //i - neuron number in x direction, i.e. 0,1,2,3 //j - neuron number in y direction, i.e. 0,1,2,3 //Following example assumes sidelength of 4 //e.g Neuron 5 - x position is (int)5/4 * 0.33 = 0.33 //then take modulus of 5%4 = 1 //Neuron 5 - y position is (int)1/1 * 0.33 = 0.33 centers[i][j - 1] = ((int)(temp / Math.Pow(sideLength, j - 1)) * (disMinMaxPosition / (sideLength - 1))) + minPosition; temp = temp % (int)(Math.Pow(sideLength, j - 1)); } //Now set the widths if ((centers[i].Contains(1) || centers[i].Contains(0)) && useWideEdgeRBFs) { widths[i] = edgeNeuronRBFWidth; } else { widths[i] = volumeNeuronRBFWidth; } //centers[i] = (double)(1 / (double)(neuronCount - 1)) * (double)i; } #endregion SetRBFCentersAndWidths(centers, widths, RBFType); //SaveOutNeuronCentersAndWeights(centers, widths); }