public void trainingStep(int ability, ref int pass)
{
pass++;
// 1. initiating ability
state = stAbilityExecuting;
// storing chosen ability
LastUsedAbility = ability;
// storing current input vectors
LastInputVecs = Cart.makeInputVector();
// finding the input vector for the top node
TopNodeInput = new double[Cart.CogTop.InputNum];
int i;
for (i = 0; i < Cart.CogTop.InputNum; i++)
{
TopNodeInput[i] = MetaNode.getOutput(Cart.CogTop.Children[i], LastInputVecs, pass);
}
// now training
double[] DesiredOutputVec = STANN.mapInt2VectorDouble(ability, 2, Cart.CogTop.stann.OutputNum);
// training 6 times
for (i = 0; i < 6; i++)
{
Cart.CogTop.stann.backPropagate(TopNodeInput, DesiredOutputVec);
}
// executing ability now..
Cart.useAbility((t_CartAbility)ability);
}
// return the output of a MetaNode branch given the input vector to the leaves
/*
* public static double getOutput(MetaNode mnet, double[][] inputvec, int pass)
* {
* int i;
* double[] sigmoids;
* double theoutput;
*
* if (mnet.ChildrenNum == 0)
* {
* if (mnet.OutputPass != pass)
* {
* mnet.OutputPass = pass;
* // self training if the node has its ForceSelfTrain attribute set to true
* if (mnet.ForcedSelfTrain)
* // self training
* mnet.stann.selfTrain(inputvec[mnet.LeafIndex]);
*
* // retrieving the sigmoids of the node
* sigmoids = mnet.stann.sigmoidLayerOutputs(inputvec[mnet.LeafIndex], mnet.stann.LayerNum - 1);
* // calculating the decimal equivalent to the ordered thresholded sigmoid outputs
* theoutput = STANN.mapVector2Int(sigmoids, 2, mnet.stann.OutputNum);
*
* mnet.PreviousOutput = mnet.CurrentOutput;
* mnet.CurrentOutput = theoutput;
* }
* else
* theoutput = mnet.CurrentOutput;
*
* }
* else
* {
* if (mnet.OutputPass != pass)
* {
* mnet.OutputPass = pass;
* double[] levelinput = new double[mnet.InputNum];
*
* for (i = 0; i < mnet.InputNum; i++)
* if (mnet.Children[i].NodeLevel >= mnet.NodeLevel) // requesting output from a higher (or equal ) level node
* levelinput[i] = mnet.Children[i].PreviousOutput; // avoiding circular reference in recursion
* else
* levelinput[i] = getOutput(mnet.Children[i], inputvec, pass);
*
* // self training if the aselfrain attribute is on
* if (mnet.ForcedSelfTrain) mnet.stann.selfTrain(levelinput);
* // retrieving sigmoids
* sigmoids = mnet.stann.sigmoidLayerOutputs(levelinput, mnet.stann.LayerNum - 1);
* // calculating the decimal equivalent to the thresholded outputs
* theoutput = 0;
* for (i = 0; i < mnet.stann.OutputNum; i++)
* {
* int bit = (sigmoids[i] < 0.5) ? 0 : 1;
* theoutput += (int)Math.Pow(2, i) * bit;
* }
* // updating previous Input Vector and Previous Output properties of the metanode
* int t;
* mnet.PreviousInputVec = new double[mnet.InputNum];
* for (t = 0; t < mnet.InputNum; t++)
* mnet.PreviousInputVec[t] = levelinput[t];
* mnet.PreviousOutput = mnet.CurrentOutput;
* mnet.CurrentOutput = theoutput;
* // previous input vector and output updated with the new values
*
* // Must now train the network!!!! (in case the qlearning property is on)
* if (mnet.ForcedQLearning)
* {
* // mapping the input to the proper index in the reward table
* int inputindex = 0;
* for (t = 0; t < mnet.InputNum; t++)
* inputindex += (int)(Math.Pow(mnet.InputRange, t) * levelinput[t]);
* // finding the output that corresponds to the maximum Qvaluefor the given input
* double maxQvalue = mnet.getMaximumQValue(inputindex);
* int maxQvalueOutputindex = 0;
* while (mnet.QTable[inputindex][maxQvalueOutputindex] != maxQvalue)
* maxQvalueOutputindex++;
*
* // converting the maximum Q value output to a vector of binary digits
* double[] desiredOutput = mnet.stann.int2BinaryVector(maxQvalueOutputindex);
* // now training...
* mnet.stann.backPropagate(levelinput, desiredOutput);
* // updating the IO log
* if (mnet.IOLogLength == MAX_IO_LOG_LENGTH)
* { // IO Log is full
* // clearing the log and starting all over again
* mnet.IOLogLength = 1;
* }
* else
* mnet.IOLogLength++;
* // updating the IO log entries
* mnet.IOLog[mnet.IOLogLength - 1].input = inputindex;
* mnet.IOLog[mnet.IOLogLength - 1].output = (int)theoutput;
*
* }
* }
* else
* theoutput = mnet.CurrentOutput;
*
* }
*
* return theoutput;
* }
*/
public static double getOutput(MetaNode mnet, double[][] inputvec, int pass)
{
int i;
double[] sigmoids;
double theoutput;
if (mnet.ChildrenNum == 0)
{
if (mnet.OutputPass != pass)
{
mnet.OutputPass = pass;
// self training if the node has its ForceSelfTrain attribute set to true
if (mnet.ForcedSelfTrain)
{
// self training
mnet.stann.selfTrain(inputvec[mnet.LeafIndex]);
}
// retrieving the sigmoids of the node
sigmoids = mnet.stann.sigmoidLayerOutputs(inputvec[mnet.LeafIndex], mnet.stann.LayerNum - 1);
// calculating the decimal equivalent to the ordered thresholded sigmoid outputs
theoutput = STANN.sigmoids2Int(sigmoids, mnet.stann.OutputNum);
mnet.PreviousOutput = mnet.CurrentOutput;
mnet.CurrentOutput = theoutput;
}
else
{
theoutput = mnet.CurrentOutput;
}
}
else
{
if (mnet.OutputPass != pass)
{
mnet.OutputPass = pass;
double[] levelinput = new double[mnet.InputNum];
for (i = 0; i < mnet.InputNum; i++)
{
if (mnet.Children[i].NodeLevel >= mnet.NodeLevel) // requesting output from a higher (or equal ) level node
{
levelinput[i] = mnet.Children[i].PreviousOutput; // avoiding circular reference in recursion
}
else
{
levelinput[i] = getOutput(mnet.Children[i], inputvec, pass);
}
}
// self training if the aselfrain attribute is on
if (mnet.ForcedSelfTrain)
{
mnet.stann.selfTrain(levelinput);
}
// retrieving sigmoids
sigmoids = mnet.stann.sigmoidLayerOutputs(levelinput, mnet.stann.LayerNum - 1);
// calculating the decimal equivalent to the thresholded outputs
theoutput = STANN.mapVector2Int(sigmoids, 2, mnet.stann.OutputNum);
// updating previous Input Vector and Previous Output properties of the metanode
int t;
mnet.PreviousInputVec = new double[mnet.InputNum];
for (t = 0; t < mnet.InputNum; t++)
{
mnet.PreviousInputVec[t] = levelinput[t];
}
mnet.PreviousOutput = mnet.CurrentOutput;
mnet.CurrentOutput = theoutput;
// previous input vector and output updated with the new values
// Must now train the network!!!! (in case the qlearning property is on)
if (mnet.ForcedQLearning)
{
// mapping the input to the proper index in the reward table
int inputindex = STANN.mapVector2Int(levelinput, mnet.InputRange, mnet.InputNum);
// finding the output that corresponds to the maximum Qvaluefor the given input
QTableEntry maxQvalueEntry = QTableEntry.getMaxQValue(mnet.QTable, inputindex);
if (maxQvalueEntry != null)
{
// converting the maximum Q value output to a vector of binary digits
double[] desiredOutput = STANN.mapInt2VectorDouble(maxQvalueEntry.Output, 2, mnet.stann.OutputNum);
// now training...
mnet.stann.backPropagate(levelinput, desiredOutput);
}
// updating the IO log
if (mnet.IOLogLength == MAX_IO_LOG_LENGTH)
{ // IO Log is full
// clearing the log and starting all over again
mnet.IOLogLength = 1;
}
else
{
mnet.IOLogLength++;
}
// updating the IO log entries
mnet.IOLog[mnet.IOLogLength - 1].input = inputindex;
mnet.IOLog[mnet.IOLogLength - 1].output = (int)theoutput;
}
}
else
{
theoutput = mnet.CurrentOutput;
}
}
return(theoutput);
}