Interface for all neural network training methods. This allows the training methods to be largely interchangeable. Though some training methods require specific types of neural network structure.
For a list of all members of this type, see ITrain Members .
| Type | Description |
|---|---|
| NeuralSimulatedAnnealing | This class implements a simulated annealing training algorithm for feed forward neural networks. It is based on the generic SimulatedAnnealing class. It is used in the same manner as any other training class that implements the Train interface. |
| BasicTraining | An abstract class that implements basic training for most training algorithms. Specifically training strategies can be added to enhance the training. |
| CompetitiveTraining | This class implements competitive training, which would be used in a winner-take-all neural network, such as the self organizing map (SOM). This is an unsupervised training method, no ideal data is needed on the training set. If ideal data is provided, it will be ignored. Training is done by looping over all of the training elements and calculating a "best matching unit" (BMU). This BMU output neuron is then adjusted to better "learn" this pattern. Additionally, this training may be applied to othr "nearby" output neurons. The degree to which nearby neurons are update is defined by the neighborhood function. A neighborhood function is required to determine the degree to which neighboring neurons (to the winning neuron) are updated by each training iteration. Because this is unsupervised training, calculating an error to measure progress by is difficult. The error is defined to be the "worst", or longest, Euclidean distance of any of the BMU's. This value should be minimized, as learning progresses. Because only the BMU neuron and its close neighbors are updated, you can end up with some output neurons that learn nothing. By default these neurons are forced to win patterns that are not represented well. This spreads out the workload among all output neurons. This feature is used by default, but can be disabled by setting the "forceWinner" property. |
| TrainInstar | Used for Instar training of a CPN neural network. A CPN network is a hybrid supervised/unsupervised network. The Instar training handles the unsupervised portion of the training. |
| TrainOutstar | Used for Instar training of a CPN neural network. A CPN network is a hybrid supervised/unsupervised network. The Outstar training handles the supervised portion of the training. |
| NeuralGeneticAlgorithm | Implements a genetic algorithm that allows a feedforward neural network to be trained using a genetic algorithm. This algorithm is for a feed forward neural network. This class is somewhat undefined. If you wish to train the neural network using training sets, you should use the TrainingSetNeuralGeneticAlgorithm class. If you wish to use a cost function to train the neural network, then implement a subclass of this one that properly calculates the cost. |
| TrainingSetNeuralGeneticAlgorithm | Implements a genetic algorithm that allows a neural network to be trained using a genetic algorithm. This algorithm is for a neural network. The neural network is trained using training sets. |
| TrainHopfield | This class is used to train a Hopfield neural network. A hopfield neural network can be created by using the basic layer and connecting it to itself, forming a single layer recurrent neural network. This is an unsupervised training algorithm. Ideal values should not be specified in the training set. If ideal values are present, they will be ignored. |
| Backpropagation | This class implements a backpropagation training algorithm for feed forward neural networks. It is used in the same manner as any other training class that implements the Train interface. Backpropagation is a common neural network training algorithm. It works by analyzing the error of the output of the neural network. Each neuron in the output layer's contribution, according to weight, to this error is determined. These weights are then adjusted to minimize this error. This process continues working its way backwards through the layers of the neural network. This implementation of the backpropagation algorithm uses both momentum and a learning rate. The learning rate specifies the degree to which the weight matrixes will be modified through each iteration. The momentum specifies how much the previous learning iteration affects the current. To use no momentum at all specify zero. One primary problem with backpropagation is that the magnitude of the partial derivative is often detrimental to the training of the neural network. The other propagation methods of Manhatten and Resilient address this issue in different ways. In general, it is suggested that you use the resilient propagation technique for most Encog training tasks over back propagation. |
| ManhattanPropagation | One problem that the backpropagation technique has is that the magnitude of the partial derivative may be calculated too large or too small. The Manhattan update algorithm attempts to solve this by using the partial derivative to only indicate the sign of the update to the weight matrix. The actual amount added or subtracted from the weight matrix is obtained from a simple constant. This constant must be adjusted based on the type of neural network being trained. In general, start with a higher constant and decrease it as needed. The Manhattan update algorithm can be thought of as a simplified version of the resilient algorithm. The resilient algorithm uses more complex techniques to determine the update value. |
| Propagation | Implements basic functionality that is needed by each of the propagation methods. The specifics of each of the propagation methods is implemented inside of the PropagationMethod interface implementors. |
| ResilientPropagation | One problem with the backpropagation algorithm is that the magnitude of the partial derivative is usually too large or too small. Further, the learning rate is a single value for the entire neural network. The resilient propagation learning algorithm uses a special update value(similar to the learning rate) for every neuron connection. Further these update values are automatically determined, unlike the learning rate of the backpropagation algorithm. For most training situations, we suggest that the resilient propagation algorithm (this class) be used for training. There are a total of three parameters that must be provided to the resilient training algorithm. Defaults are provided for each, and in nearly all cases, these defaults are acceptable. This makes the resilient propagation algorithm one of the easiest and most efficient training algorithms available. The optional parameters are: zeroTolerance - How close to zero can a number be to be considered zero. The default is 0.00000000000000001. initialUpdate - What are the initial update values for each matrix value. The default is 0.1. maxStep - What is the largest amount that the update values can step. The default is 50. |
| TrainAdaline | Train an ADALINE neural network. |
Namespace: Encog.Neural.Networks.Training
Assembly: encog-core-cs (in encog-core-cs.dll)