/// <summary>
/// Construct an RPROP job. For more information on RPROP see the
/// ResilientPropagation class.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">True if binary training data should be loaded to memory.</param>
/// <param name="localRatio">The local ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="globalRatio">The global ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="segmentationRatio">The segmentation ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="iterationsPer">How many iterations to process per cycle.</param>
public RPROPJob(BasicNetwork network, INeuralDataSet training,
bool loadToMemory, double localRatio, int globalRatio, double segmentationRatio, int iterationsPer) :
this(network, training,
loadToMemory, RPROPConst.DEFAULT_INITIAL_UPDATE,
RPROPConst.DEFAULT_MAX_STEP, localRatio, globalRatio, segmentationRatio, iterationsPer)
{
}
/// <summary>
/// Construct a cross trainer.
/// </summary>
/// <param name="network">The network.</param>
/// <param name="training">The training data.</param>
public CrossTraining(BasicNetwork network,
FoldedDataSet training)
{
this.network = network;
Training = training;
this.folded = training;
}
/// <inheritdoc />
public override void Randomize(BasicNetwork network)
{
for (var i = 0; i < network.Weights.Length; i++)
{
network.Weights[i] = Rnd.NextDouble(_low, _high);
}
}
/// <summary>
/// Construct the depth calculation object.
/// </summary>
/// <param name="network">The network that we are calculating for.</param>
public CalculateDepth(BasicNetwork network)
{
this.network = network;
this.outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
if( this.outputLayer!=null )
Calculate(0, this.outputLayer);
}
/// <summary>
/// Determine if the two neural networks are equal.
/// </summary>
///
/// <param name="network1">The first network.</param>
/// <param name="network2">The second network.</param>
/// <param name="precision">How many decimal places to check.</param>
/// <returns>True if the two networks are equal.</returns>
public static bool Equals(BasicNetwork network1,
BasicNetwork network2, int precision)
{
double[] array1 = NetworkToArray(network1);
double[] array2 = NetworkToArray(network2);
if (array1.Length != array2.Length)
{
return false;
}
double test = Math.Pow(10.0d, precision);
if (Double.IsInfinity(test) || (test > Int64.MaxValue))
{
throw new NeuralNetworkError("Precision of " + precision
+ " decimal places is not supported.");
}
for (int i = 0; i < array1.Length; i++)
{
var l1 = (long) (array1[i]*test);
var l2 = (long) (array2[i]*test);
if (l1 != l2)
{
return false;
}
}
return true;
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="learnRate">The learning rate.</param>
public ManhattanPropagation(BasicNetwork network,
IMLDataSet training, double learnRate)
: base(network, training)
{
_learningRate = learnRate;
_zeroTolerance = RPROPConst.DefaultZeroTolerance;
}
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(BasicNetwork network,
IMLDataSet training, double learnRate)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
LearningRate = learnRate;
}
/// <summary>
/// Construct a Hopfield training class.
/// </summary>
/// <param name="trainingSet">The training set to use.</param>
/// <param name="network">The network to train.</param>
public TrainHopfield(INeuralDataSet trainingSet,
BasicNetwork network)
{
this.network = network;
this.Training = trainingSet;
this.Error = 0;
}
/// <inheritdoc />
public override void Randomize(BasicNetwork network)
{
for (var i = 0; i < network.Layers.Count - 1; i++)
{
RandomizeLayer(network, i);
}
}
/// <summary>
/// Construct the LMA object.
/// </summary>
/// <param name="network">The network to train. Must have a single output neuron.</param>
/// <param name="training">The training data to use. Must be indexable.</param>
public SVDTraining(BasicNetwork network, INeuralDataSet training)
{
ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
if (outputLayer == null)
{
throw new TrainingError("SVD requires an output layer.");
}
if (outputLayer.NeuronCount != 1)
{
throw new TrainingError("SVD requires an output layer with a single neuron.");
}
if (network.GetLayer(RadialBasisPattern.RBF_LAYER) == null)
throw new TrainingError("SVD is only tested to work on radial basis function networks.");
rbfLayer = (RadialBasisFunctionLayer)network.GetLayer(RadialBasisPattern.RBF_LAYER);
this.Training = training;
this.network = network;
this.trainingLength = (int)this.Training.InputSize;
BasicNeuralData input = new BasicNeuralData(this.Training.InputSize);
BasicNeuralData ideal = new BasicNeuralData(this.Training.IdealSize);
this.pair = new BasicNeuralDataPair(input, ideal);
}
/// <summary>
/// Construct a neural genetic algorithm.
/// </summary>
///
/// <param name="network">The network to base this on.</param>
/// <param name="randomizer">The randomizer used to create this initial population.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
/// <param name="mutationPercent">The percent of offspring to mutate.</param>
/// <param name="percentToMate">The percent of the population allowed to mate.</param>
public NeuralGeneticAlgorithm(BasicNetwork network,
IRandomizer randomizer, ICalculateScore calculateScore,
int populationSize, double mutationPercent,
double percentToMate)
: base(TrainingImplementationType.Iterative)
{
Genetic = new NeuralGeneticAlgorithmHelper
{
CalculateScore = new GeneticScoreAdapter(calculateScore)
};
IPopulation population = new BasicPopulation(populationSize);
Genetic.MutationPercent = mutationPercent;
Genetic.MatingPopulation = percentToMate*2;
Genetic.PercentToMate = percentToMate;
Genetic.Crossover = new Splice(network.Structure.CalculateSize()/3);
Genetic.Mutate = new MutatePerturb(4.0d);
Genetic.Population = population;
for (int i = 0; i < population.PopulationSize; i++)
{
var chromosomeNetwork = (BasicNetwork) (network
.Clone());
randomizer.Randomize(chromosomeNetwork);
var genome = new NeuralGenome(chromosomeNetwork) {GA = Genetic};
Genetic.PerformCalculateScore(genome);
Genetic.Population.Add(genome);
}
population.Sort();
}
/// <summary>
/// Format the network as a human readable string that lists the
/// hidden layers.
/// </summary>
/// <param name="network">The network to format.</param>
/// <returns>A human readable string.</returns>
public static String NetworkToString(BasicNetwork network)
{
StringBuilder result = new StringBuilder();
int num = 1;
ILayer layer = network.GetLayer(BasicNetwork.TAG_INPUT);
// display only hidden layers
while (layer.Next.Count > 0)
{
layer = layer.Next[0].ToLayer;
if (result.Length > 0)
{
result.Append(",");
}
result.Append("H");
result.Append(num++);
result.Append("=");
result.Append(layer.NeuronCount);
}
return result.ToString();
}
/// <summary>
/// Determine the network size.
/// </summary>
/// <param name="network">The network to check.</param>
/// <returns>The size of the network.</returns>
public static int NetworkSize(BasicNetwork network)
{
// see if there is already an up to date flat network
if (network.Structure.Flat != null
&& (network.Structure.FlatUpdate == FlatUpdateNeeded.None
|| network.Structure.FlatUpdate == FlatUpdateNeeded.Unflatten))
{
return network.Structure.Flat.Weights.Length;
}
int index = 0;
// loop over all of the layers, take the output layer first
foreach (ILayer layer in network.Structure.Layers)
{
// see if the previous layer, which is the next layer that the loop will hit,
// is either a connection to a BasicLayer or a ContextLayer.
ISynapse synapse = network.Structure
.FindPreviousSynapseByLayerType(layer, typeof(BasicLayer));
ISynapse contextSynapse = network.Structure.FindPreviousSynapseByLayerType(
layer, typeof(ContextLayer));
// get a list of of the previous synapses to this layer
IList<ISynapse> list = network.Structure.GetPreviousSynapses(layer);
// If there is not a BasicLayer or contextLayer as the next layer, then
// just take the first synapse of any type.
if (synapse == null && contextSynapse == null && list.Count > 0)
{
synapse = list[0];
}
// is there any data to record for this synapse?
if (synapse != null && synapse.WeightMatrix != null)
{
// process each weight matrix
for (int x = 0; x < synapse.ToNeuronCount; x++)
{
index += synapse.FromNeuronCount;
if (synapse.ToLayer.HasBias)
{
index++;
}
if (contextSynapse != null)
{
index += contextSynapse.FromNeuronCount;
}
}
}
}
return index;
}
/// <summary>
/// Construct the instar training object.
/// </summary>
/// <param name="network">The network to be trained.</param>
/// <param name="training">The training data.</param>
/// <param name="learningRate">The learning rate.</param>
public TrainInstar(BasicNetwork network, INeuralDataSet training,
double learningRate)
{
this.network = network;
this.training = training;
this.learningRate = learningRate;
this.parts = new FindCPN(network);
}
/// <summary>
/// Construct a job definition for RPROP. For more information on backprop,
/// see the Backpropagation class.
/// </summary>
/// <param name="network">The network to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">Should binary data be loaded to memory?</param>
/// <param name="learningRate">THe learning rate to use.</param>
/// <param name="momentum">The momentum to use.</param>
public BPROPJob(BasicNetwork network, INeuralDataSet training,
bool loadToMemory, double learningRate,
double momentum)
: base(network, training, loadToMemory)
{
this.LearningRate = learningRate;
this.Momentum = momentum;
}
/// <summary>
/// Construct a training class.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
public ScaledConjugateGradient(BasicNetwork network,
INeuralDataSet training)
: base(network, training)
{
TrainFlatNetworkSCG rpropFlat = new TrainFlatNetworkSCG(
network.Structure.Flat,
this.Training);
this.FlatTraining = rpropFlat;
}
/// <summary>
/// Construct a QPROP trainer for flat networks.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learnRate">The learning rate. 2 is a good suggestion as
/// a learning rate to start with. If it fails to converge,
/// then drop it. Just like backprop, except QPROP can
/// take higher learning rates.</param>
public QuickPropagation(BasicNetwork network,
IMLDataSet training, double learnRate)
: base(network, training)
{
ValidateNetwork.ValidateMethodToData(network, training);
LearningRate = learnRate;
LastDelta = new double[Network.Flat.Weights.Length];
OutputEpsilon = 1.0;
}
public void Execute(IExampleInterface app)
{
GetSunSpots();
EvaluateEnd = EvaluateStart + 100;
NormalizeSunspots(-1, 1);
BasicNetwork network = (BasicNetwork)CreateElmanNetwork(WindowSize);
IMLDataSet training = GenerateTraining();
Train(network, training);
Predict(network);
}
public void Execute(int write)
{
this.write = write;
_normalizedTrainingData = NormalizeData(trainingData);
_normalizedPredictionData = NormalizeData(predictionData);
network = CreateNetwork();
IMLDataSet training = GenerateTraining();
Train(training);
Predict();
}
public static BasicNetwork CreateNetwork(int inputSize, int outputSize)
{
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(null, true, inputSize));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, inputSize));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, outputSize));
network.Structure.FinalizeStructure();
network.Reset();
return(network);
}
private void CreateNetwork(FileInfo networkFile)
{
network = new BasicNetwork();
network.AddLayer(new BasicLayer(new ActivationLinear(), true, 22));
network.AddLayer(new BasicLayer(new ActivationTANH(), true, 6));
network.AddLayer(new BasicLayer(new ActivationTANH(), false, 1));
network.Structure.FinalizeStructure();
network.Reset();
EncogDirectoryPersistence.SaveObject(networkFile, (BasicNetwork)network);
}
public BasicNetwork Create()
{
BasicNetwork network = XOR.CreateTrainedXOR();
XOR.VerifyXOR(network, 0.1);
network.SetProperty("test", "test2");
return(network);
}
public static void Compute <T>(BasicNetwork network, ILearningScenario <T> scenario,
IList <T> dataSource)
{
var computingSet = scenario.GetSet(dataSource);
foreach (var item in computingSet)
{
var output = network.Compute(item.Input);
Console.WriteLine($"Input: {item.Input[0]}, {item.Input[1]} Ideal: {item.Ideal[0]} Actual: {output[0]}");
}
}
protected virtual BasicNetwork BuildNetwork(TimeSeries simulatedData, out NormalizeArray norm)
{
double[] data = GenerateData(simulatedData);
double[] normalizedData = NormalizeData(data, mNormalizedLow, mNormalzedHigh, out norm);
BasicNetwork network = CreateNetwork();
IMLDataSet training = GenerateTraining(normalizedData);
Train(network, training);
return(network);
}
/// <inheritdoc/>
public virtual void Init(BasicNetwork theNetwork, IMLDataSet theTraining)
{
int weightCount = theNetwork.Structure.Flat.Weights.Length;
flat = theNetwork.Flat;
training = theTraining;
network = theNetwork;
gradients = new double[weightCount];
hessianMatrix = new Matrix(weightCount, weightCount);
hessian = hessianMatrix.Data;
derivative = new double[weightCount];
}
public RedNeuronal()
{
trainingSet = new BasicMLDataSet(neuralInput, neuralOutput);
this.network = new BasicNetwork();
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 72));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 216));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 144));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 12));
network.Structure.FinalizeStructure();
network.Reset();
train = new ResilientPropagation(network, trainingSet);
}
/// <summary>
/// Initializes this neural network.
/// </summary>
private void InitializeNetwork()
{
NeuralNetwork = new BasicNetwork();
foreach (var l in Parameters.Layers)
{
NeuralNetwork.AddLayer(new BasicLayer(l.ActivationFunction, l.Bias, l.NueronCount));
}
NeuralNetwork.Structure.FinalizeStructure();
NeuralNetwork.Reset();
}
/// <summary>
/// Use an array to populate the memory of the neural network.
/// </summary>
/// <param name="array">An array of doubles.</param>
/// <param name="network">The network to encode.</param>
public static void ArrayToNetwork(double[] array,
BasicNetwork network)
{
int index = 0;
foreach (ILayer layer in network.Structure.Layers)
{
index = NetworkCODEC.ProcessLayer(network, layer, array, index);
}
network.Structure.FlatUpdate = FlatUpdateNeeded.Flatten;
}
/// <summary>
/// Construct a training job.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">True, if binary data should be loaded to memory.</param>
public TrainingJob(BasicNetwork network,
INeuralDataSet training, bool loadToMemory)
: base()
{
this.Network = network;
this.Training = training;
this.LoadToMemory = loadToMemory;
this.IterationsPer = 1;
this.LocalRatio = 1.0;
this.GlobalRatio = 1;
this.SegmentationRatio = 1.0;
}
/// <summary>
/// Create a feed forward network.
/// </summary>
///
/// <param name="architecture">The architecture string to use.</param>
/// <param name="input">The input count.</param>
/// <param name="output">The output count.</param>
/// <returns>The feedforward network.</returns>
public IMLMethod Create(String architecture, int input,
int output)
{
var result = new BasicNetwork();
IList <String> layers = ArchitectureParse.ParseLayers(architecture);
IActivationFunction af = new ActivationLinear();
int questionPhase = 0;
foreach (String layerStr in layers)
{
// determine default
int defaultCount = questionPhase == 0 ? input : output;
ArchitectureLayer layer = ArchitectureParse.ParseLayer(
layerStr, defaultCount);
bool bias = layer.Bias;
String part = layer.Name;
part = part != null?part.Trim() : "";
IActivationFunction lookup = _factory.Create(part);
if (lookup != null)
{
af = lookup;
}
else
{
if (layer.UsedDefault)
{
questionPhase++;
if (questionPhase > 2)
{
throw new EncogError("Only two ?'s may be used.");
}
}
if (layer.Count == 0)
{
throw new EncogError("Unknown architecture element: "
+ architecture + ", can't parse: " + part);
}
result.AddLayer(new BasicLayer(af, bias, layer.Count));
}
}
result.Structure.FinalizeStructure();
result.Reset();
return(result);
}
/// <summary>
/// Construct a network analyze class. Analyze the specified network.
/// </summary>
/// <param name="network">The network to analyze.</param>
public AnalyzeNetwork(BasicNetwork network)
{
int assignDisabled = 0;
int assignedTotal = 0;
IList <double> biasList = new List <double>();
IList <double> weightList = new List <double>();
IList <double> allList = new List <double>();
foreach (ILayer layer in network.Structure.Layers)
{
if (layer.HasBias)
{
for (int i = 0; i < layer.NeuronCount; i++)
{
biasList.Add(layer.BiasWeights[i]);
allList.Add(layer.BiasWeights[i]);
}
}
}
foreach (ISynapse synapse in network.Structure.Synapses)
{
if (synapse.MatrixSize > 0)
{
for (int from = 0; from < synapse.FromNeuronCount; from++)
{
for (int to = 0; to < synapse.ToNeuronCount; to++)
{
if (network.IsConnected(synapse, from, to))
{
double d = synapse.WeightMatrix[from, to];
weightList.Add(d);
allList.Add(d);
}
else
{
assignDisabled++;
}
assignedTotal++;
}
}
}
}
this.disabledConnections = assignDisabled;
this.totalConnections = assignedTotal;
this.weights = new NumericRange(weightList);
this.bias = new NumericRange(biasList);
this.weightsAndBias = new NumericRange(allList);
this.weightValues = EngineArray.ListToDouble(weightList);
this.allValues = EngineArray.ListToDouble(allList);
this.biasValues = EngineArray.ListToDouble(biasList);
}
/// <summary>
/// Construct an RPROP job. For more information on RPROP see the
/// ResilientPropagation class.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">True if binary training data should be loaded to memory.</param>
/// <param name="initialUpdate">The initial update.</param>
/// <param name="maxStep">The max step.</param>
/// <param name="localRatio">The local ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="globalRatio">The global ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="segmentationRatio">The segmentation ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="iterationsPer">How many iterations to process per cycle.</param>
public RPROPJob(BasicNetwork network, INeuralDataSet training,
bool loadToMemory, double initialUpdate,
double maxStep, double localRatio, int globalRatio, double segmentationRatio, int iterationsPer) :
base(network, training, loadToMemory)
{
this.InitialUpdate = initialUpdate;
this.MaxStep = maxStep;
this.LocalRatio = localRatio;
this.GlobalRatio = globalRatio;
this.SegmentationRatio = segmentationRatio;
this.IterationsPer = iterationsPer;
}
/// <summary>
/// Determine if the specified neural network can be flat. If it can a null
/// is returned, otherwise, an error is returned to show why the network
/// cannot be flattened.
/// </summary>
/// <param name="eml">The network to check.</param>
/// <returns>Null, if the net can not be flattened, an error message
/// otherwise.</returns>
public override String IsValid(IEngineMachineLearning eml)
{
if (!(eml is BasicNetwork))
{
return("Only a BasicNetwork can be converted to a flat network.");
}
BasicNetwork network = (BasicNetwork)eml;
ILayer inputLayer = network.GetLayer(BasicNetwork.TAG_INPUT);
ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
if (inputLayer == null)
{
return("To convert to a flat network, there must be an input layer.");
}
if (outputLayer == null)
{
return("To convert to a flat network, there must be an output layer.");
}
if (!(network.Logic is FeedforwardLogic) ||
(network.Logic is ThermalLogic))
{
return("To convert to flat, must be using FeedforwardLogic or SimpleRecurrentLogic.");
}
foreach (ILayer layer in network.Structure.Layers)
{
if (layer.Next.Count > 2)
{
return("To convert to flat a network must have at most two outbound synapses.");
}
if (layer.GetType() != typeof(ContextLayer) &&
layer.GetType() != typeof(BasicLayer) &&
layer.GetType() != typeof(RadialBasisFunctionLayer))
{
return("To convert to flat a network must have only BasicLayer and ContextLayer layers.");
}
}
foreach (ISynapse synapse in network.Structure.Synapses)
{
if (synapse is NEATSynapse)
{
return("A NEAT synapse cannot be flattened.");
}
}
return(null);
}
public void TestNeuronSignificance()
{
BasicNetwork network = ObtainNetwork();
PruneSelective prune = new PruneSelective(network);
double inputSig = prune.DetermineNeuronSignificance(0, 1);
double hiddenSig = prune.DetermineNeuronSignificance(1, 1);
double outputSig = prune.DetermineNeuronSignificance(2, 1);
Assert.AreEqual(63.0, inputSig, 0.01);
Assert.AreEqual(95.0, hiddenSig, 0.01);
Assert.AreEqual(26.0, outputSig, 0.01);
}
/// <summary>
/// Construct an RPROP job. For more information on RPROP see the
/// ResilientPropagation class.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">True if binary training data should be loaded to memory.</param>
/// <param name="initialUpdate">The initial update.</param>
/// <param name="maxStep">The max step.</param>
/// <param name="localRatio">The local ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="globalRatio">The global ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="segmentationRatio">The segmentation ratio, used if this job is performed by an OpenCL Device.</param>
/// <param name="iterationsPer">How many iterations to process per cycle.</param>
public RPROPJob(BasicNetwork network, INeuralDataSet training,
bool loadToMemory, double initialUpdate,
double maxStep, double localRatio, int globalRatio, double segmentationRatio, int iterationsPer) :
base(network, training, loadToMemory)
{
this.InitialUpdate = initialUpdate;
this.MaxStep = maxStep;
this.LocalRatio = localRatio;
this.GlobalRatio = globalRatio;
this.SegmentationRatio = segmentationRatio;
this.IterationsPer = iterationsPer;
}
private static Task <EncogTrainingResponse> GetTrainedNetworkAsync2(TrainingData training, double hiddenMultiplier, double maxError, CancellationToken cancelToken, double?maxSeconds = null)
{
return(Task.Run(() =>
{
// Create a network, build input/hidden/output layers
//TODO: Figure out why telling it to use the faster activation functions always causes the trainer to return an error of NaN
BasicNetwork network = CreateNetwork2(training, hiddenMultiplier, false);
// Train the network
return TrainNetwork2(network, training, maxError, cancelToken, maxSeconds); // lower score is better
}, cancelToken));
}
/// <summary>
/// Use an array to populate the memory of the neural network.
/// </summary>
/// <param name="array">An array of doubles.</param>
/// <param name="network">The network to encode.</param>
public static void ArrayToNetwork(double[] array,
BasicNetwork network)
{
int index = 0;
foreach (ILayer layer in network.Structure.Layers)
{
index = NetworkCODEC.ProcessLayer(network, layer, array, index);
}
network.Structure.FlatUpdate = FlatUpdateNeeded.Flatten;
}
private void init(int layers = 4, int neuronsPerLayer = 15)
{
Network = new BasicNetwork();
Network.AddLayer(new BasicLayer(null, true, inputNumber));
for (int i = 0; i < layers; i++)
{
Network.AddLayer(new BasicLayer(new ActivationElliott(), true, neuronsPerLayer));
}
Network.AddLayer(new BasicLayer(new ActivationSoftMax(), false, 6));
Network.Structure.FinalizeStructure();
Network.Reset();
}
private GameState GetMinMax(List <MinMaxBranch> Branches, BasicNetwork Network)
{
foreach (var b in Branches)
{
foreach (var l in b.Leafs)
{
var Compute = ((BasicMLData)Network.Compute(l.Head.GetData()));
l.Score = Compute.Data[0];
}
}
return(Branches.OrderBy(x => x.GetScore()).First().GetFirstChoice());
}
static BasicNetwork UtworzSiecDoRegresji()
{
BasicNetwork network = new BasicNetwork();
network.AddLayer(new BasicLayer(null, true, 1)); //Neurony wejsciowe
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 20)); //Warstwa ukryta
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); //Wyjścia
network.Structure.FinalizeStructure();
network.Reset();
return(network);
}
private string SaveNetwork(BasicNetwork network)
{
double[] data = new double[network.EncodedArrayLength()];
network.EncodeToArray(data);
List <byte> netData = new List <byte>();
foreach (double d in data)
{
netData.AddRange(BitConverter.GetBytes(d));
}
return(Convert.ToBase64String(netData.ToArray()));
}
public double EvaluateRandomizer(IRandomizer randomizer,
BasicNetwork network, IMLDataSet training)
{
double total = 0;
for (int i = 0; i < SAMPLE_SIZE; i++)
{
randomizer.Randomize(network);
total += Evaluate(network, training);
}
return(total / SAMPLE_SIZE);
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
renderer = new Render(spriteBatch, GraphicsDevice);
graphics.PreferredBackBufferWidth = 700; // set this value to the desired width of your window
graphics.PreferredBackBufferHeight = 700; // set this value to the desired height of your window
graphics.ApplyChanges();
net = Trainer.train(renderer);
debugGame = new SnakeGame();
}
private void ProcessNetwork()
{
app.WriteLine("Downsampling images...");
foreach (ImagePair pair in imageList)
{
IMLData ideal = new BasicMLData(outputCount);
int idx = pair.Identity;
for (int i = 0; i < outputCount; i++)
{
if (i == idx)
{
ideal.Data[i] = 1;
}
else
{
ideal.Data[i] = -1;
}
}
try
{
var img = new Bitmap(pair.File);
var data = new ImageMLData(img);
training.Add(data, ideal);
}
catch (Exception e)
{
app.WriteLine("Error loading: " + pair.File
+ ": " + e.Message);
}
}
String strHidden1 = GetArg("hidden1");
String strHidden2 = GetArg("hidden2");
if (training.Count == 0)
{
app.WriteLine("No images to create network for.");
return;
}
training.Downsample(downsampleHeight, downsampleWidth);
int hidden1 = int.Parse(strHidden1);
int hidden2 = int.Parse(strHidden2);
network = EncogUtility.SimpleFeedForward(training
.InputSize, hidden1, hidden2,
training.IdealSize, true);
app.WriteLine("Created network: " + network);
}
/// <summary>
/// Construct the backpropagation trainer.
/// </summary>
/// <param name="theNetwork">The network to train.</param>
/// <param name="theTraining">The training data to use.</param>
/// <param name="theLearningRate">The learning rate. Can be changed as training runs.</param>
/// <param name="theMomentum">The momentum. Can be changed as training runs.</param>
public BackPropagation(BasicNetwork theNetwork, IList<BasicData> theTraining, double theLearningRate,
double theMomentum)
{
BatchSize = 500;
Stochastic = new MersenneTwisterGenerateRandom();
NesterovUpdate = true;
_network = theNetwork;
_training = theTraining;
LearningRate = theLearningRate;
Momentum = theMomentum;
_gradients = new GradientCalc(_network, new CrossEntropyErrorFunction(), this);
_lastDelta = new double[theNetwork.Weights.Length];
}
public void Train(BasicNetwork network, IMLDataSet training)
{
ITrain train = new ResilientPropagation(network, training);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
} while (train.Error > MaxError);
}
/// <summary>
/// Setup the network logic, read parameters from the network.
/// </summary>
/// <param name="network">The network that this logic class belongs to.</param>
public override void Init(BasicNetwork network)
{
base.Init(network);
ILayer layer = this.Network.GetLayer(BasicNetwork.TAG_INPUT);
this.on = new int[layer.NeuronCount];
this.off = new int[layer.NeuronCount];
this.temperature = this.Network.GetPropertyDouble(BoltzmannLogic.PROPERTY_TEMPERATURE);
this.runCycles = (int)this.Network.GetPropertyLong(BoltzmannLogic.PROPERTY_RUN_CYCLES);
this.annealCycles = (int)this.Network.GetPropertyLong(BoltzmannLogic.PROPERTY_ANNEAL_CYCLES);
}
public BasicNetwork GetNetwork()
{
var network = new BasicNetwork();
foreach (NeuralLayerInfo layer in Layers)
{
var objLayer = layer.GetLayer();
network.AddLayer(objLayer);
}
network.FinalizeStructure();
network.Reset();
return(network);
}
public void Execute(IExampleInterface app)
{
this.app = app;
BasicNetwork network = generateNetwork();
IMLDataSet data = generateTraining();
double rprop = EvaluateRPROP(network, data);
double mprop = EvaluateMPROP(network, data);
double factor = rprop / mprop;
Console.WriteLine("Factor improvement:" + factor);
}
/// <summary>
/// Construct an ADALINE trainer.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="learningRate">The learning rate.</param>
public TrainAdaline(BasicNetwork network, IMLDataSet training,
double learningRate) : base(TrainingImplementationType.Iterative)
{
if (network.LayerCount > 2)
{
throw new NeuralNetworkError(
"An ADALINE network only has two layers.");
}
_network = network;
_training = training;
_learningRate = learningRate;
}
/// <summary>
/// Construct the backpropagation trainer.
/// </summary>
/// <param name="theNetwork">The network to train.</param>
/// <param name="theTraining">The training data to use.</param>
/// <param name="theLearningRate">The learning rate. Can be changed as training runs.</param>
/// <param name="theMomentum">The momentum. Can be changed as training runs.</param>
public BackPropagation(BasicNetwork theNetwork, IList <BasicData> theTraining, double theLearningRate,
double theMomentum)
{
BatchSize = 500;
Stochastic = new MersenneTwisterGenerateRandom();
NesterovUpdate = true;
_network = theNetwork;
_training = theTraining;
LearningRate = theLearningRate;
Momentum = theMomentum;
_gradients = new GradientCalc(_network, new CrossEntropyErrorFunction(), this);
_lastDelta = new double[theNetwork.Weights.Length];
}
/// <summary>
/// Construct a training job.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="loadToMemory">True, if binary data should be loaded to memory.</param>
public TrainingJob(BasicNetwork network,
INeuralDataSet training, bool loadToMemory)
: base()
{
this.Network = network;
this.Training = training;
this.LoadToMemory = loadToMemory;
this.IterationsPer = 1;
this.LocalRatio = 1.0;
this.GlobalRatio = 1;
this.SegmentationRatio = 1.0;
}
/// <summary>
/// Construct a simulated annleaing trainer for a feedforward neural network.
/// </summary>
///
/// <param name="network">The neural network to be trained.</param>
/// <param name="calculateScore">Used to calculate the score for a neural network.</param>
/// <param name="startTemp">The starting temperature.</param>
/// <param name="stopTemp">The ending temperature.</param>
/// <param name="cycles">The number of cycles in a training iteration.</param>
public NeuralSimulatedAnnealing(BasicNetwork network,
ICalculateScore calculateScore, double startTemp,
double stopTemp, int cycles) : base(TrainingImplementationType.Iterative)
{
_network = network;
_calculateScore = calculateScore;
_anneal = new NeuralSimulatedAnnealingHelper(this)
{
Temperature = startTemp,
StartTemperature = startTemp,
StopTemperature = stopTemp,
Cycles = cycles
};
}
/// <summary>
/// Construct he ADALINE trainer.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training set.</param>
/// <param name="learningRate">The learning rate.</param>
public TrainAdaline(BasicNetwork network, INeuralDataSet training,
double learningRate)
{
if (network.Structure.Layers.Count > 2)
throw new NeuralNetworkError(
"An ADALINE network only has two layers.");
this.network = network;
ILayer input = network.GetLayer(BasicNetwork.TAG_INPUT);
this.synapse = input.Next[0];
this.training = training;
this.learningRate = learningRate;
}
/// <summary>
/// The Xaiver initialization works layer by layer.
/// </summary>
/// <param name="network">The network.</param>
/// <param name="fromLayer">The source layer.</param>
private void RandomizeLayer(BasicNetwork network, int fromLayer)
{
var fromCount = network.GetLayerTotalNeuronCount(fromLayer);
var toCount = network.Layers[fromLayer + 1].Count;
for (var fromNeuron = 0; fromNeuron < fromCount; fromNeuron++)
{
for (var toNeuron = 0; toNeuron < toCount; toNeuron++)
{
var sigma = Math.Sqrt(2.0/(fromCount + toCount));
var w = Rnd.NextGaussian()*sigma;
network.SetWeight(fromLayer, fromNeuron, toNeuron, w);
}
}
}
/// <summary>
/// Construct a neural genome.
/// </summary>
///
/// <param name="network">The network to use.</param>
public NeuralGenome(BasicNetwork network)
{
Organism = network;
_networkChromosome = new Chromosome();
// create an array of "double genes"
int size = network.Structure.CalculateSize();
for (int i = 0; i < size; i++)
{
IGene gene = new DoubleGene();
_networkChromosome.Genes.Add(gene);
}
Chromosomes.Add(_networkChromosome);
Encode();
}
/// <summary>
/// Construct a neural network genome.
/// </summary>
/// <param name="nga">The neural genetic algorithm.</param>
/// <param name="network">The network.</param>
public NeuralGenome(NeuralGeneticAlgorithm nga, BasicNetwork network)
: base(nga.Helper)
{
this.Organism = network;
this.networkChromosome = new Chromosome();
// create an array of "double genes"
int size = network.Structure.CalculateSize();
for (int i = 0; i < size; i++)
{
IGene gene = new DoubleGene();
this.networkChromosome.Genes.Add(gene);
}
this.Chromosomes.Add(this.networkChromosome);
Encode();
}
/// <summary>
/// Construct a Manhattan propagation training object.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="training">The training data to use.</param>
/// <param name="profile">The learning rate.</param>
/// <param name="learnRate">The OpenCL profile to use, null for CPU.</param>
public ManhattanPropagation(BasicNetwork network,
INeuralDataSet training, OpenCLTrainingProfile profile, double learnRate)
: base(network, training)
{
if (profile == null)
{
FlatTraining = new TrainFlatNetworkManhattan(
network.Structure.Flat,
this.Training,
learnRate);
}
#if !SILVERLIGHT
else
{
TrainFlatNetworkOpenCL rpropFlat = new TrainFlatNetworkOpenCL(
network.Structure.Flat, this.Training,
profile);
rpropFlat.LearnManhattan(learnRate);
this.FlatTraining = rpropFlat;
}
#endif
}
/// <summary>
/// Generate the Elman neural network.
/// </summary>
/// <returns>The Elman neural network.</returns>
public BasicNetwork Generate()
{
int y = PatternConst.START_Y;
ILayer input = new BasicLayer(this.activation, false,
this.inputNeurons);
BasicNetwork result = new BasicNetwork();
result.AddLayer(input);
input.X = PatternConst.START_X;
input.Y = y;
y += PatternConst.INC_Y;
foreach (int count in this.hidden)
{
ILayer hidden = new BasicLayer(
this.activation, true, count);
result.AddLayer(hidden);
hidden.X = PatternConst.START_X;
hidden.Y = y;
y += PatternConst.INC_Y;
}
ILayer output = new BasicLayer(this.activation, true,
this.outputNeurons);
result.AddLayer(output);
output.X = PatternConst.START_X;
output.Y = y;
y += PatternConst.INC_Y;
result.Structure.FinalizeStructure();
result.Reset();
return result;
}
/// <summary>
/// Setup the network logic, read parameters from the network.
/// </summary>
/// <param name="network">The network that this logic class belongs to.</param>
public virtual void Init(BasicNetwork network)
{
this.network = network;
}
