protected CrossTraining(IMLMethod network, FoldedDataSet training)
: base(TrainingImplementationType.Iterative)
{
this._x87a7fc6a72741c2e = network;
this.Training = training;
this._x3952df2eab48841c = training;
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double startTemp = holder.GetDouble(
MLTrainFactory.PropertyTemperatureStart, false, 10);
double stopTemp = holder.GetDouble(
MLTrainFactory.PropertyTemperatureStop, false, 2);
int cycles = holder.GetInt(MLTrainFactory.Cycles, false, 100);
IMLTrain train = new NeuralSimulatedAnnealing(
(BasicNetwork)method, score, startTemp, stopTemp, cycles);
return(train);
}
/// <summary>
/// The Nguyen-Widrow initialization algorithm is the following :
///
/// 1. Initialize all weight of hidden layers with (ranged) random values
/// 2. For each hidden layer
/// 2.1 calculate beta value, 0.7/// Nth(#neurons of input layer) root of
/// #neurons of current layer
/// 2.2 for each synapse
/// 2.1.1 for each weight
/// 2.1.2 Adjust weight by dividing by norm of weight for neuron and
/// multiplying by beta value
/// </summary>
/// <param name="method">The network to randomize.</param>
public override sealed void Randomize(IMLMethod method)
{
if (!(method is BasicNetwork))
{
throw new EncogError("Ngyyen Widrow only works on BasicNetwork.");
}
var network = (BasicNetwork) method;
new RangeRandomizer(Min, Max).Randomize(network);
int hiddenNeurons = 0;
for (int i = 1; i < network.LayerCount - 1; i++)
{
hiddenNeurons += network.GetLayerTotalNeuronCount(i);
}
// can't really do much, use regular randomization
if (hiddenNeurons < 1)
{
return;
}
_inputCount = network.InputCount;
_beta = 0.7d*Math.Pow(hiddenNeurons, 1.0d/network.InputCount);
base.Randomize(network);
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
int populationSize = holder.GetInt(
MLTrainFactory.PropertyPopulationSize, false, 5000);
double mutation = holder.GetDouble(
MLTrainFactory.PropertyMutation, false, 0.1d);
double mate = holder.GetDouble(MLTrainFactory.PropertyMate,
false, 0.25d);
IMLTrain train = new NeuralGeneticAlgorithm((BasicNetwork) method,
new RangeRandomizer(-1, 1), score, populationSize, mutation,
mate);
return train;
}
/// <summary>
/// Perform the training option.
/// </summary>
public void Train()
{
// first, create the machine learning method
var methodFactory = new MLMethodFactory();
IMLMethod method = methodFactory.Create(Config.MethodType, Config.MethodArchitecture, Config.InputWindow, 1);
// second, create the data set
string filename = FileUtil.CombinePath(new FileInfo(_path), Config.FilenameTrain).ToString();
IMLDataSet dataSet = EncogUtility.LoadEGB2Memory(new FileInfo(filename));
// third, create the trainer
var trainFactory = new MLTrainFactory();
IMLTrain train = trainFactory.Create(method, dataSet, Config.TrainType, Config.TrainParams);
// reset if improve is less than 1% over 5 cycles
if (method is IMLResettable && !(train is ManhattanPropagation))
{
train.AddStrategy(new RequiredImprovementStrategy(500));
}
// fourth, train and evaluate.
EncogUtility.TrainToError(train, Config.TargetError);
method = train.Method;
EncogDirectoryPersistence.SaveObject(FileUtil.CombinePath(new FileInfo(_path), Config.MethodName), method);
// finally, write out what we did
Console.WriteLine(@"Machine Learning Type: " + Config.MethodType);
Console.WriteLine(@"Machine Learning Architecture: " + Config.MethodArchitecture);
Console.WriteLine(@"Training Method: " + Config.TrainType);
Console.WriteLine(@"Training Args: " + Config.TrainParams);
}
public double CalculateError()
{
IMLMethod method = ObtainMethod();
IMLDataSet data = ObtainTrainingSet();
return(((IMLError)method).CalculateError(data));
}
/// <inheritdoc />
public void CalculateScore(IGenome g)
{
// try rewrite
Rules.Rewrite(g);
// decode
IMLMethod phenotype = CODEC.Decode(g);
double score;
// deal with invalid decode
if (phenotype == null)
{
score = BestComparer.ShouldMinimize ? Double.PositiveInfinity : Double.NegativeInfinity;
}
else
{
var context = phenotype as IMLContext;
if (context != null)
{
context.ClearContext();
}
score = ScoreFunction.CalculateScore(phenotype);
}
// now set the scores
g.Score = score;
g.AdjustedScore = score;
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string argsStr)
{
if (!(method is SupportVectorMachine))
{
throw new EncogError("SVM Train training cannot be used on a method of type: " + method.GetType().FullName);
}
double defaultValue = 1.0 / ((double) ((SupportVectorMachine) method).InputCount);
while (true)
{
double num4;
SVMTrain train;
double num2 = 1.0;
IDictionary<string, string> theParams = ArchitectureParse.ParseParams(argsStr);
ParamsHolder holder = new ParamsHolder(theParams);
double num3 = holder.GetDouble("GAMMA", false, defaultValue);
do
{
num4 = holder.GetDouble("C", false, num2);
train = new SVMTrain((SupportVectorMachine) method, training) {
Gamma = num3
};
}
while (((uint) defaultValue) > uint.MaxValue);
if ((((uint) num2) + ((uint) num3)) <= uint.MaxValue)
{
train.C = num4;
return train;
}
}
}
/// <summary>
/// Create a SVM trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is SupportVectorMachine))
{
throw new EncogError(
"SVM Train training cannot be used on a method of type: "
+ method.GetType().FullName);
}
double defaultGamma = 1.0d / ((SupportVectorMachine)method).InputCount;
double defaultC = 1.0d;
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double gamma = holder.GetDouble(MLTrainFactory.PropertyGamma,
false, defaultGamma);
double c = holder.GetDouble(MLTrainFactory.PropertyC, false,
defaultC);
var result = new SVMTrain((SupportVectorMachine)method, training);
result.Gamma = gamma;
result.C = c;
return(result);
}
public void Process(String methodName, String methodArchitecture, String trainerName, String trainerArgs,
int outputNeurons)
{
// first, create the machine learning method
var methodFactory = new MLMethodFactory();
IMLMethod method = methodFactory.Create(methodName, methodArchitecture, 2, outputNeurons);
// second, create the data set
IMLDataSet dataSet = new BasicMLDataSet(XORInput, XORIdeal);
// third, create the trainer
var trainFactory = new MLTrainFactory();
IMLTrain train = trainFactory.Create(method, dataSet, trainerName, trainerArgs);
// reset if improve is less than 1% over 5 cycles
if (method is IMLResettable && !(train is ManhattanPropagation))
{
train.AddStrategy(new RequiredImprovementStrategy(500));
}
// fourth, train and evaluate.
EncogUtility.TrainToError(train, 0.01);
method = train.Method;
EncogUtility.Evaluate((IMLRegression)method, dataSet);
// finally, write out what we did
Console.WriteLine(@"Machine Learning Type: " + methodName);
Console.WriteLine(@"Machine Learning Architecture: " + methodArchitecture);
Console.WriteLine(@"Training Method: " + trainerName);
Console.WriteLine(@"Training Args: " + trainerArgs);
}
/// <summary>
/// Construct a cross trainer.
/// </summary>
///
/// <param name="network">The network.</param>
/// <param name="training">The training data.</param>
protected CrossTraining(IMLMethod network, FoldedDataSet training)
: base(TrainingImplementationType.Iterative)
{
_network = network;
Training = training;
_folded = training;
}
public double CalculateScore(IMLMethod network)
{
EncogLogisticsPilot pilot = new EncogLogisticsPilot((BasicNetwork)network, Metadata);
var logisticOutput = pilot.ScorePilot(CustomerOrders);
return(logisticOutput.Score);
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
int populationSize = holder.GetInt(
MLTrainFactory.PropertyPopulationSize, false, 5000);
IMLTrain train = new MLMethodGeneticAlgorithm(() =>
{
IMLMethod result = (IMLMethod)ObjectCloner.DeepCopy(method);
((IMLResettable)result).Reset();
return(result);
}, score, populationSize);
return(train);
}
/// <summary>
/// Crossvalidate and fit.
/// </summary>
/// <param name="k">The number of folds.</param>
/// <param name="shuffle">True if we should shuffle.</param>
/// <returns>The trained method.</returns>
public IMLMethod Crossvalidate(int k, bool shuffle)
{
var cross = new KFoldCrossvalidation(
TrainingDataset, k);
cross.Process(shuffle);
int foldNumber = 0;
foreach (DataFold fold in cross.Folds)
{
foldNumber++;
Report.Report(k, foldNumber, "Fold #" + foldNumber);
FitFold(k, foldNumber, fold);
}
double sum = 0;
double bestScore = Double.PositiveInfinity;
IMLMethod bestMethod = null;
foreach (DataFold fold in cross.Folds)
{
sum += fold.Score;
if (fold.Score < bestScore)
{
bestScore = fold.Score;
bestMethod = fold.Method;
}
}
sum = sum / cross.Folds.Count;
Report.Report(k, k, "Cross-validated score:" + sum);
return(bestMethod);
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
int populationSize = holder.GetInt(
MLTrainFactory.PropertyPopulationSize, false, 5000);
IMLTrain train = new MLMethodGeneticAlgorithm( () => {
IMLMethod result = (IMLMethod) ObjectCloner.DeepCopy(method);
((IMLResettable)result).Reset();
return result;
}, score, populationSize);
return train;
}
/// <summary>
/// Create a SVM trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is SupportVectorMachine))
{
throw new EncogError(
"SVM Train training cannot be used on a method of type: "
+ method.GetType().FullName);
}
double defaultGamma = 1.0d/((SupportVectorMachine) method).InputCount;
double defaultC = 1.0d;
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double gamma = holder.GetDouble(MLTrainFactory.PropertyGamma,
false, defaultGamma);
double c = holder.GetDouble(MLTrainFactory.PropertyC, false,
defaultC);
var result = new SVMTrain((SupportVectorMachine) method, training);
result.Gamma = gamma;
result.C = c;
return result;
}
public double CalculateScore(IMLMethod network)
{
var pilot = new NeuralRobot((BasicNetwork)network, false, RobotContol.SourceLocation, RobotContol.DestLocation);
int score = pilot.ScorePilot();
//RobotContol.Scores.Add(score);
return score;
}
/// <summary>
/// Perform the training.
/// </summary>
/// <param name="train">The training method.</param>
/// <param name="method">The ML method.</param>
/// <param name="trainingSet">The training set.</param>
private void PerformTraining(IMLTrain train, IMLMethod method,
IMLDataSet trainingSet)
{
ValidateNetwork.ValidateMethodToData(method, trainingSet);
double targetError = Prop.GetPropertyDouble(
ScriptProperties.MlTrainTargetError);
Analyst.ReportTrainingBegin();
int maxIteration = Analyst.MaxIteration;
if (train.ImplementationType == TrainingImplementationType.OnePass)
{
train.Iteration();
Analyst.ReportTraining(train);
}
else
{
do
{
train.Iteration();
Analyst.ReportTraining(train);
} while ((train.Error > targetError) &&
!Analyst.ShouldStopCommand() &&
!train.TrainingDone &&
((maxIteration == -1) || (train.IterationNumber < maxIteration)));
}
train.FinishTraining();
Analyst.ReportTrainingEnd();
}
/// <summary>
/// The Nguyen-Widrow initialization algorithm is the following :
///
/// 1. Initialize all weight of hidden layers with (ranged) random values
/// 2. For each hidden layer
/// 2.1 calculate beta value, 0.7/// Nth(#neurons of input layer) root of
/// #neurons of current layer
/// 2.2 for each synapse
/// 2.1.1 for each weight
/// 2.1.2 Adjust weight by dividing by norm of weight for neuron and
/// multiplying by beta value
/// </summary>
/// <param name="method">The network to randomize.</param>
public override sealed void Randomize(IMLMethod method)
{
if (!(method is BasicNetwork))
{
throw new EncogError("Ngyyen Widrow only works on BasicNetwork.");
}
var network = (BasicNetwork)method;
new RangeRandomizer(Min, Max).Randomize(network);
int hiddenNeurons = 0;
for (int i = 1; i < network.LayerCount - 1; i++)
{
hiddenNeurons += network.GetLayerTotalNeuronCount(i);
}
// can't really do much, use regular randomization
if (hiddenNeurons < 1)
{
return;
}
_inputCount = network.InputCount;
_beta = 0.7d * Math.Pow(hiddenNeurons, 1.0d / network.InputCount);
base.Randomize(network);
}
public override sealed void Randomize(IMLMethod method)
{
if (!(method is BasicNetwork))
{
throw new EncogError("Ngyyen Widrow only works on BasicNetwork.");
}
BasicNetwork network = (BasicNetwork) method;
Label_00B3:
new RangeRandomizer(base.Min, base.Max).Randomize(network);
int num = 0;
int l = 1;
while (true)
{
if (l >= (network.LayerCount - 1))
{
if ((num >= 1) && ((((uint) num) + ((uint) l)) <= uint.MaxValue))
{
this._x43f451310e815b76 = network.InputCount;
this._xd7d571ecee49d1e4 = 0.7 * Math.Pow((double) num, 1.0 / ((double) network.InputCount));
base.Randomize(network);
return;
}
return;
}
num += network.GetLayerTotalNeuronCount(l);
if (((uint) l) < 0)
{
goto Label_00B3;
}
l++;
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="theAlgorithm">The algorithm to fit.</param>
/// <param name="theScore">The score function.</param>
/// <param name="thePopulationSize">The population size.</param>
public ContinuousACO(IMLMethod theAlgorithm, IScoreFunction theScore, int thePopulationSize)
{
Epsilon = .75;
_algorithm = theAlgorithm;
_populationSize = thePopulationSize;
_score = theScore;
Random = new MersenneTwisterGenerateRandom();
_paramCount = theAlgorithm.LongTermMemory.Length;
_population = new ContinuousAnt[thePopulationSize * 2];
_weighting = new double[thePopulationSize];
for (int i = 0; i < _population.Length; i++)
{
_population[i] = new ContinuousAnt(_paramCount, _score.ShouldMinimize);
for (int j = 0; j < _paramCount; j++)
{
_population[i].Params[j] = Random.NextDouble(-1, 1);
}
}
UpdateScore();
Array.Sort(_population);
ComputeWeighting();
SampleSolutions();
Array.Sort(_population);
}
public IGenome Encode(IMLMethod phenotype)
{
var rbfNet = (RBFNetwork) phenotype;
var result = new DoubleArrayGenome(Size);
Array.Copy(rbfNet.LongTermMemory, 0, result.Data, 0, _size);
return result;
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
int populationSize = holder.GetInt(
MLTrainFactory.PropertyPopulationSize, false, 5000);
double mutation = holder.GetDouble(
MLTrainFactory.PropertyMutation, false, 0.1d);
double mate = holder.GetDouble(MLTrainFactory.PropertyMate,
false, 0.25d);
IMLTrain train = new NeuralGeneticAlgorithm((BasicNetwork)method,
new RangeRandomizer(-1, 1), score, populationSize, mutation,
mate);
return(train);
}
/// <summary>
/// Create an annealing trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
if (!(method is BasicNetwork))
{
throw new TrainingError(
"Invalid method type, requires BasicNetwork");
}
ICalculateScore score = new TrainingSetScore(training);
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double startTemp = holder.GetDouble(
MLTrainFactory.PropertyTemperatureStart, false, 10);
double stopTemp = holder.GetDouble(
MLTrainFactory.PropertyTemperatureStop, false, 2);
int cycles = holder.GetInt(MLTrainFactory.Cycles, false, 100);
IMLTrain train = new NeuralSimulatedAnnealing(
(BasicNetwork) method, score, startTemp, stopTemp, cycles);
return train;
}
/// <summary>
/// Create an NEAT GA trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
ICalculateScore score = new TrainingSetScore(training);
TrainEA train = NEATUtil.ConstructNEATTrainer((NEATPopulation)method, score);
return(train);
}
public IGenome Encode(IMLMethod phenotype)
{
var rbfNet = (RBFNetwork)phenotype;
var result = new DoubleArrayGenome(Size);
Array.Copy(rbfNet.LongTermMemory, 0, result.Data, 0, _size);
return(result);
}
/// <inheritdoc />
public double CalculateScore(IMLMethod genome)
{
var prg = (EncogProgram) genome;
var pop = (PrgPopulation) prg.Population;
IMLData inputData = new BasicMLData(pop.Context.DefinedVariables.Count);
prg.Compute(inputData);
return 0;
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string args)
{
if (!(method is BasicNetwork))
{
throw new EncogError("SCG training cannot be used on a method of type: " + method.GetType().FullName);
}
return new ScaledConjugateGradient((BasicNetwork) method, training);
}
public override double CalculateScore(IMLMethod network)
{
gameManager.Player2 = new NeuralColorPlayer(gameManager.Rules as VanDerWaerdenGameRules) { Network = network as BasicNetwork };
var scores = new int[NGames];
for (int i = 0; i < NGames; i++)
scores[i] = gameManager.PlayGame();
return CalculateScore(scores);
}
/// <summary>
/// Create an NEAT GA trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
ICalculateScore score = new TrainingSetScore(training);
TrainEA train = NEATUtil.ConstructNEATTrainer((NEATPopulation)method, score);
return train;
}
public static int NetworkSize(IMLMethod network)
{
if (!(network is IMLEncodable))
{
throw new NeuralNetworkError("This machine learning method cannot be encoded:" + network.GetType().FullName);
}
return ((IMLEncodable) network).EncodedArrayLength();
}
public static void ArrayToNetwork(double[] array, IMLMethod network)
{
if (!(network is IMLEncodable))
{
throw new NeuralNetworkError("This machine learning method cannot be encoded:" + network.GetType().FullName);
}
((IMLEncodable) network).DecodeFromArray(array);
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string argsStr)
{
if (!(method is SOMNetwork))
{
throw new EncogError("Cluster SOM training cannot be used on a method of type: " + method.GetType().FullName);
}
return new SOMClusterCopyTraining((SOMNetwork) method, training);
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string args)
{
if (!(method is RBFNetwork))
{
throw new EncogError("RBF-SVD training cannot be used on a method of type: " + method.GetType().FullName);
}
return new SVDTraining((RBFNetwork) method, training);
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string args)
{
if (!(method is BasicPNN))
{
throw new EncogError("PNN training cannot be used on a method of type: " + method.GetType().FullName);
}
return new TrainBasicPNN((BasicPNN) method, training);
}
/// <summary>
/// Returns total sum of distance between cities represnted in the chromosome
/// </summary>
/// <param name="phenotype"></param>
/// <returns></returns>
public double CalculateScore(IMLMethod phenotype)
{
try
{
FourBitCustomGenome genome = (FourBitCustomGenome)phenotype;
FourBitGene [] genomeData = ((FourBitCustomGenome)genome).Data;
//double maxPossiblePower = PowerUnits.Sum(x => x.UnitCapacity);
new PowerUnitGALogic().DisplayGeneAsString(genome, genomeData);
var intervalFitnessDataRepository = new IntervalFitnessDataRepository(MaxPossiblePower);
var intervalRawData = intervalFitnessDataRepository.IntervalRawData;
for (int i = 0; i < NumberOfIntervals; i++)
{
IntervalsFitnessData interval = intervalRawData[i];
//interval.MaxReserve = maxPossiblePower;
for (int j = 0; j < genomeData.Length; j++)
{
PowerUnit powerUnit = PowerUnits[j];
FourBitGene fourBitGene = genomeData[j];
int geneBitIndex = i;
var isPowerUnitMaintained = fourBitGene.Gene[geneBitIndex] == 1;
if (isPowerUnitMaintained)
{
interval.ReducedAmountOnMaintainance = interval.ReducedAmountOnMaintainance + (1 * powerUnit.UnitCapacity);
}
else
{
interval.ReducedAmountOnMaintainance = interval.ReducedAmountOnMaintainance + (0 * powerUnit.UnitCapacity);
}
}
var totalPowerReductionOnMaintanceAndUsage =
interval.PowerRequirement + interval.ReducedAmountOnMaintainance;
interval.ReserveAfterMaintainance = interval.MaxReserve - totalPowerReductionOnMaintanceAndUsage;
//if (interval.ReserveAfterMaintainance < 0.0)
//{
// // the chromosome is not suitable for out requirement
// chromosomeFitness = 0.0;
//}
}
var reserveAfterMaintainanceMin = intervalRawData.Min(x => x.ReserveAfterMaintainance);
// minimal rerserve after maintainance and usage provides chormosomes fitness
//var chromosomeFitness = reserveAfterMaintainanceMin > 0.0 ? reserveAfterMaintainanceMin : 0.0;
var chromosomeFitness = reserveAfterMaintainanceMin;
Console.WriteLine("\tFitness = {0} - of {1}, {2}, {3}, {4}", chromosomeFitness,
intervalRawData[0].ReserveAfterMaintainance, intervalRawData[1].ReserveAfterMaintainance,
intervalRawData[2].ReserveAfterMaintainance, intervalRawData[3].ReserveAfterMaintainance);
return(chromosomeFitness);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Determine the network size.
/// </summary>
///
/// <param name="network">The network.</param>
/// <returns>The size.</returns>
public static int NetworkSize(IMLMethod network)
{
if (network is IMLEncodable)
{
return(((IMLEncodable)network).EncodedArrayLength());
}
throw new NeuralNetworkError(Error
+ network.GetType().FullName);
}
/// <inheritdoc />
public double CalculateScore(IMLMethod genome)
{
var prg = (EncogProgram)genome;
var pop = (PrgPopulation)prg.Population;
IMLData inputData = new BasicMLData(pop.Context.DefinedVariables.Count);
prg.Compute(inputData);
return(0);
}
static void Main(string[] args)
{
// used for prediction of time series
// sin(x) in theory
int DEGREES = 360;
int WINDOW_SIZE = 16;
double[][] Input = new double[DEGREES][];
double[][] Ideal = new double[DEGREES][];
// Create array of sin signals
for (int i = 0; i < DEGREES; i++)
{
Input[i] = new double[WINDOW_SIZE];
Ideal[i] = new double[] { Math.Sin(DegreeToRad(i + WINDOW_SIZE)) };
for (int j = 0; j < WINDOW_SIZE; j++)
{
Input[i][j] = Math.Sin(DegreeToRad(i + j));
}
}
// construct training set
IMLDataSet trainingSet = new BasicMLDataSet(Input, Ideal);
// construct an Elman type network
// simple recurrent network
ElmanPattern pattern = new ElmanPattern
{
InputNeurons = WINDOW_SIZE,
ActivationFunction = new ActivationSigmoid(),
OutputNeurons = 1
};
pattern.AddHiddenLayer(WINDOW_SIZE);
IMLMethod method = pattern.Generate();
BasicNetwork network = (BasicNetwork)method;
// Train network
IMLTrain train = new Backpropagation(network, trainingSet);
var stop = new StopTrainingStrategy();
train.AddStrategy(new Greedy());
train.AddStrategy(stop);
int epoch = 0;
while (!stop.ShouldStop())
{
train.Iteration();
Console.WriteLine($"Training Epoch #{epoch} Error:{train.Error}");
epoch++;
}
// Test network
foreach (IMLDataPair pair in trainingSet)
{
IMLData output = network.Compute(pair.Input);
Console.WriteLine($"actual={output[0]}, ideal={pair.Ideal[0]}");
}
}
/// <inheritdoc/>
public double CalculateScore(IMLMethod method)
{
double result = 0;
foreach (FitnessObjective obj in this.objectives)
{
result += obj.Score.CalculateScore(method) * obj.Weight;
}
return(result);
}
/// <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,
IMLMethod network)
{
if (network is IMLEncodable)
{
((IMLEncodable) network).DecodeFromArray(array);
return;
}
throw new NeuralNetworkError(Error
+ network.GetType().FullName);
}
public double CalculateScore(IMLMethod network)
{
double ret = 0;
for (int i = 0; i < 10; i++)
{
Pond p = new Pond((BasicNetwork)network, null);
ret += p.tick(100);
}
return(ret / 10);
}
public double CalculateScore(IMLMethod network)
{
int cnt = Interlocked.Increment(ref sessionCnt);
EncogLogisticSimulator sim = new EncogLogisticSimulator((BasicNetwork)network, false);
var score = sim.CalculateScore(CustomerOrders, false);
Console.WriteLine($"Session #{cnt} \t Score: {Math.Abs(score).ToString("$#,##0")}");
return(score);
}
/// <summary>
/// Create a Nelder Mead trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
//final double learningRate = holder.getDouble(
// MLTrainFactory.PROPERTY_LEARNING_RATE, false, 0.1);
return(new NelderMeadTraining((BasicNetwork)method, training));
}
public void Execute(IExampleInterface app)
{
IMLDataSet trainingData = GenerateTraining(InputOutputCount, Compl);
IMLMethod method = EncogUtility.SimpleFeedForward(InputOutputCount,
HiddenCount, 0, InputOutputCount, false);
var train = new LevenbergMarquardtTraining((BasicNetwork)method, trainingData);
EncogUtility.TrainToError(train, 0.01);
EncogFramework.Instance.Shutdown();
}
/// <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,
IMLMethod network)
{
if (network is IMLEncodable)
{
((IMLEncodable)network).DecodeFromArray(array);
return;
}
throw new NeuralNetworkError(Error
+ network.GetType().FullName);
}
/// <summary>
/// Create a quick propagation trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double learningRate = holder.GetDouble(
MLTrainFactory.PropertyLearningRate, false, 2.0);
return new QuickPropagation((BasicNetwork) method, training, learningRate);
}
/// <summary>
/// Create a Nelder Mead trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
//final double learningRate = holder.getDouble(
// MLTrainFactory.PROPERTY_LEARNING_RATE, false, 0.1);
return new NelderMeadTraining((BasicNetwork)method, training);
}
/// <inheritdoc/>
public double CalculateScore(IMLMethod method)
{
double result = 0;
foreach (FitnessObjective obj in this.objectives)
{
result += obj.Score.CalculateScore(method) * obj.Weight;
}
return result;
}
/// <summary>
/// Is the specified method supported for code generation?
/// </summary>
/// <param name="method">The specified method.</param>
/// <returns>True, if the specified method is supported.</returns>
public static bool IsSupported(IMLMethod method)
{
if (method is BasicNetwork)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Create a quick propagation trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary <String, String> args = ArchitectureParse.ParseParams(argsStr);
var holder = new ParamsHolder(args);
double learningRate = holder.GetDouble(
MLTrainFactory.PropertyLearningRate, false, 2.0);
return(new QuickPropagation((BasicNetwork)method, training, learningRate));
}
/// <summary>
/// Construct the simulated annealing trainer.
/// </summary>
/// <param name="theAlgorithm">The algorithm to optimize.</param>
/// <param name="theScore">The score function.</param>
/// <param name="theKMax">The max number of iterations.</param>
/// <param name="theStartingTemperature">The starting temperature.</param>
/// <param name="theEndingTemperature">The ending temperature.</param>
public TrainAnneal(IMLMethod theAlgorithm, IScoreFunction theScore, int theKMax,
double theStartingTemperature, double theEndingTemperature)
{
_algorithm = theAlgorithm;
_score = theScore;
_kMax = theKMax;
_currentError = _score.CalculateScore(_algorithm);
_startingTemperature = theStartingTemperature;
_endingTemperature = theEndingTemperature;
_globalBest = new double[theAlgorithm.LongTermMemory.Length];
Array.Copy(_algorithm.LongTermMemory, 0, _globalBest, 0, _globalBest.Length);
}
/// <summary>
/// Create a RBF-SVD trainer.
/// </summary>
///
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="args">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String args)
{
if (!(method is RBFNetwork))
{
throw new EncogError(
"RBF-SVD training cannot be used on a method of type: "
+ method.GetType().FullName);
}
return(new SVDTraining((RBFNetwork)method, training));
}
public double CalculateScore(IMLMethod network)
{
var Player1 = new PlayerNetwork((BasicNetwork)network);
var Score = 0d;
foreach (var Player2 in Adversaries)
{
var Game = PlayOneRound(Player1, Player2.Player, Player2.PlayerStart);
Score += ScoreGame(Game, Player2);
}
return(Score);
}
/// <inheritdoc/>
public double CalculateScore(IMLMethod algo)
{
var ralgo = (IRegressionAlgorithm)algo;
// evaulate
_errorCalc.Clear();
foreach (var pair in _trainingData)
{
double[] output = ralgo.ComputeRegression(pair.Input);
_errorCalc.UpdateError(output, pair.Ideal, 1.0);
}
return _errorCalc.Calculate();
}
public IMLTrain Create(IMLMethod method, IMLDataSet training, string argsStr)
{
if (method is IContainsFlat)
{
ParamsHolder holder = new ParamsHolder(ArchitectureParse.ParseParams(argsStr));
double initialUpdate = holder.GetDouble("INIT_UPDATE", false, 0.1);
double maxStep = holder.GetDouble("MAX_STEP", false, 50.0);
if ((((uint) initialUpdate) - ((uint) maxStep)) >= 0)
{
return new ResilientPropagation((IContainsFlat) method, training, initialUpdate, maxStep);
}
}
throw new EncogError("RPROP training cannot be used on a method of type: " + method.GetType().FullName);
}
/// <summary>
/// Randomize the specified BasicNetwork.
/// </summary>
/// <param name="method">The network to randomize.</param>
public void Randomize(IMLMethod method)
{
if (!(method is BasicNetwork))
{
throw new EncogError("Nguyen-Widrow only supports BasicNetwork.");
}
BasicNetwork network = (BasicNetwork)method;
for (int fromLayer = 0; fromLayer < network.LayerCount - 1; fromLayer++)
{
RandomizeSynapse(network, fromLayer);
}
}
/// <inheritdoc/>
public double CalculateScore(IMLMethod algo)
{
IErrorCalculation ec = ErrorCalc.Create();
IRegressionAlgorithm ralgo = (IRegressionAlgorithm)algo;
// evaulate
ec.Clear();
foreach (BasicData pair in _trainingData)
{
double[] output = ralgo.ComputeRegression(pair.Input);
ec.UpdateError(output, pair.Ideal, 1.0);
}
return ec.Calculate();
}
/// <summary>
/// Create a PSO trainer.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="training">The training data to use.</param>
/// <param name="argsStr">The arguments to use.</param>
/// <returns>The newly created trainer.</returns>
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
ParamsHolder holder = new ParamsHolder(args);
int particles = holder.GetInt(
MLTrainFactory.PropertyParticles, false, 20);
ICalculateScore score = new TrainingSetScore(training);
IRandomizer randomizer = new NguyenWidrowRandomizer();
IMLTrain train = new NeuralPSO((BasicNetwork)method, randomizer, score, particles);
return train;
}
/**
* Create a K2 trainer.
*
* @param method
* The method to use.
* @param training
* The training data to use.
* @param argsStr
* The arguments to use.
* @return The newly created trainer.
*/
public IMLTrain Create(IMLMethod method,
IMLDataSet training, String argsStr)
{
IDictionary<String, String> args = ArchitectureParse.ParseParams(argsStr);
ParamsHolder holder = new ParamsHolder(args);
int maxParents = holder.GetInt(
MLTrainFactory.PropertyMaxParents, false, 1);
String searchStr = holder.GetString("SEARCH", false, "k2");
String estimatorStr = holder.GetString("ESTIMATOR", false, "simple");
String initStr = holder.GetString("INIT", false, "naive");
IBayesSearch search;
IBayesEstimator estimator;
BayesianInit init;
if( string.Compare(searchStr,"k2",true)==0) {
search = new SearchK2();
} else if( string.Compare(searchStr,"none",true)==0) {
search = new SearchNone();
}
else {
throw new BayesianError("Invalid search type: " + searchStr);
}
if( string.Compare(estimatorStr,"simple",true)==0) {
estimator = new SimpleEstimator();
} else if( string.Compare(estimatorStr, "none",true)==0) {
estimator = new EstimatorNone();
}
else {
throw new BayesianError("Invalid estimator type: " + estimatorStr);
}
if( string.Compare(initStr, "simple") ==0) {
init = BayesianInit.InitEmpty;
} else if( string.Compare(initStr, "naive") ==0) {
init = BayesianInit.InitNaiveBayes;
} else if( string.Compare(initStr, "none") ==0) {
init = BayesianInit.InitNoChange;
}
else {
throw new BayesianError("Invalid init type: " + initStr);
}
return new TrainBayesian((BayesianNetwork) method, training, maxParents, init, search, estimator);
}
