/// <summary>
/// Gets solution and record ideal score
/// </summary>
/// <param name="outputs"></param>
/// <returns></returns>
public GetSolutionResult GetSolutionFromOutputs(IEnumerable <RlmIOWithValue> outputs)
{
GetSolutionResult retVal = new GetSolutionResult();
Solution solution = null;
// generate key based on output values
long solutionId = Util.GenerateHashKey(outputs.Select(a => a.Value).ToArray());
// create new solution if not exists
if (!Solutions.TryGetValue(solutionId, out solution))
{
solution = new Solution()
{
ID = solutionId
};
foreach (var o in outputs)
{
// create OVS instance
var ovs = new Output_Values_Solution()
{
ID = Util.GenerateHashKey(solutionId, o.ID),
Value = o.Value,
Output_ID = o.ID,
Solution_ID = solutionId
};
solution.Output_Values_Solutions.Add(ovs);
// insert into dynamic output collection
HashSet <SolutionOutputSet> outputSet = DynamicOutputs[o.ID];
outputSet.Add(new SolutionOutputSet()
{
SolutionId = solutionId,
Value = o.Value
});
}
Solutions.TryAdd(solution.ID, solution);
//Solutions2.Enqueue(retVal);
//solution_queue.Add(retVal);
retVal.Solution = solution;
retVal.ExistsInCache = false;
}
else
{
retVal.Solution = solution;
retVal.ExistsInCache = true;
}
return(retVal);
}
//Record Case
private static Case RecordCase(RlmCycle cycle, GetRneuronResult rneuronFound, IEnumerable <RlmIOWithValue> rnn_ins, IEnumerable <RlmIOWithValue> runn_outs,
double cyclescore, GetSolutionResult solutionFound, Int16 currentmfactor, bool resultcompletelyrandom, short sequentialmfactorsuccessescount)
{
Case casefromdb = cycle.CaseReference; //db.Cases.Find(cycle.CycleCaseID);
//db.Sessions.Attach(casefromdb.Session);
//db.Entry(casefromdb.Session).State = EntityState.Unchanged;
//casefromdb.Session = db.Sessions.Find(casefromdb.Session.ID);
//Check for none found
if (casefromdb == null)
{
throw new Exception("An error occurred, the current case could not be located in the database.");
}
//Check for none found
if (rneuronFound.Rneuron == null)
{
throw new Exception("An error occurred, the current Rnueron could not be located in the database.");
}
//Check for none found
if (solutionFound.Solution == null)
{
throw new Exception("An error occurred, the current Solution could not be located in the database.");
}
//Assign Values
//casefromdb.Rneuron = rneuron;
casefromdb.Rneuron_ID = rneuronFound.Rneuron.ID;
casefromdb.Rneuron = (rneuronFound.ExistsInCache) ? null : rneuronFound.Rneuron;
//casefromdb.Idea_Implementations --> Later
casefromdb.Solution_ID = solutionFound.Solution.ID;
casefromdb.Solution = (solutionFound.ExistsInCache) ? null : solutionFound.Solution;
casefromdb.CycleEndTime = DateTime.Now;
casefromdb.CycleScore = cyclescore;
casefromdb.CurrentRFactor = 0;// rneuron.RandomizationFactor;
casefromdb.CurrentMFactor = currentmfactor;
casefromdb.ResultCompletelyRandom = resultcompletelyrandom;
casefromdb.SequentialMFactorSuccessesCount = sequentialmfactorsuccessescount;
return(casefromdb);
}
/// <summary>
/// Gets a random solution from outputs or randomize
/// </summary>
/// <param name="randomnessCurrVal"></param>
/// <param name="outputs"></param>
/// <param name="bestSolutionId"></param>
/// <returns></returns>
public GetSolutionResult GetRandomSolutionFromOutput(double randomnessCurrVal, IEnumerable <RlmIO> outputs, long?bestSolutionId = null, IEnumerable <RlmIdea> ideas = null)
{
GetSolutionResult retVal = null;
if (outputs.Count() == 1)
{
IEnumerable <RlmIOWithValue> outputWithValues = GetRandomOutputValues(outputs, ideas);
retVal = GetSolutionFromOutputs(outputWithValues);
}
else
{
var outputsWithVal = new List <RlmIOWithValue>();
// check if best solution was passed in as parameter or not
if (bestSolutionId.HasValue)
{
IEnumerable <Output_Values_Solution> bestOutputs = null;
int cntRandomValues = 0;
foreach (var item in outputs)
{
// use best solution value if randomness outside threshold
int randomnessValue = Util.Randomizer.Next(1, 101);
if (randomnessValue > randomnessCurrVal)
{
if (bestOutputs == null)
{
//bestOutputs = db.Output_Values_Solutions.Where(a => a.Solution_ID == bestSolutionId.Value);
Solution solution = Solutions[bestSolutionId.Value];
bestOutputs = solution.Output_Values_Solutions;
}
var bestOutput = bestOutputs.FirstOrDefault(a => a.Output_ID == item.ID);
outputsWithVal.Add(new RlmIOWithValue(item, bestOutput.Value));
}
else // get random value
{
RlmIdea idea = null;
if (ideas != null)
{
idea = ideas.FirstOrDefault(a => a.RlmIOId == item.ID);
}
string value = GetRandomValue(item, idea);
outputsWithVal.Add(new RlmIOWithValue(item, value));
cntRandomValues++;
}
}
// if no random values were assigned then we randomly select one to randomize
// this is to ensure we have at least one random output value
if (cntRandomValues == 0)
{
var index = Util.Randomizer.Next(0, outputsWithVal.Count);
var output = outputsWithVal.ElementAt(index);
RlmIdea idea = null;
if (ideas != null)
{
idea = ideas.FirstOrDefault(a => a.RlmIOId == output.ID);
}
string value = GetRandomValue(output, idea);
output.Value = value;
}
}
else // no best solution, so we give out all random values
{
outputsWithVal.AddRange(GetRandomOutputValues(outputs, ideas));
}
retVal = GetSolutionFromOutputs(outputsWithVal);
}
return(retVal);
}
internal static RlmCycleOutput CoreCycleProcess(RlmNetwork rnn_net, RlmCycle rnn_cyc, IEnumerable <Models.RlmIOWithValue> rnn_ins, RlmNetworkType rnnType, IEnumerable <Models.RlmIOWithValue> rnn_outs, double cyclescore, IEnumerable <RlmIdea> ideas = null, IEnumerable <long> excludeSolutions = null)
{
var memoryMgr = rnn_net.MemoryManager;
// temp benchmark only
//rnn_net.CurrentCycleCount++;
// temp benhcmark only
// Determine if any inputs are of Linear type
bool hasLinearInputs = rnn_ins.Any(a => a.Type == RlmInputType.Linear);
// update input momentums
if (hasLinearInputs)
{
foreach (var item in rnn_ins)
{
if (item.Type == RlmInputType.Linear)
{
var inputMomentumObj = rnn_net.InputMomentums[item.ID];
inputMomentumObj.SetInputValue(Convert.ToDouble(item.Value));
item.InputMomentum = inputMomentumObj;
}
}
}
//Get rneuron
GetRneuronResult rneuronFound = memoryMgr.GetRneuronFromInputs(rnn_ins, rnn_net.CurrentNetworkID);
Rneuron neuron = rneuronFound.Rneuron;
//Holds the solution instance
GetSolutionResult solutionFound = new GetSolutionResult();
Solution solution = null;
IEnumerable <Models.RlmIO> outputs = rnn_net.Outputs;
bool completelyRandom = false;
double randomnessValue = rnn_net.RandomnessCurrentValue;
if (rnnType == RlmNetworkType.Supervised)
{
//Supervised, get solution and record ideal score
solutionFound = memoryMgr.GetSolutionFromOutputs(rnn_outs);
solution = solutionFound.Solution;
cyclescore = IDEAL_SCORE;
}
else if (rnnType == RlmNetworkType.Unsupervised && randomnessValue > 0)
{
//TODO: This should be based upon the randomization factor
double randomProbability = Util.GetRandomDoubleNumber(0, 100);
bool random = randomProbability <= randomnessValue;
//Idea
//ToDo: Implement Ideas
//The idea implementation will not be added until core functionality works. It is an "extra" and the network can learn without it. In fact, since it reduces load, we need
//to test without it in place first. Otherwise networks that don't have an applicable "idea" may crash
//System.Diagnostics.Debug.WriteLine("Threshold: " + randomnThreshold);
long?bestSolutionId = null;
if (!random)
{
// get best solution
solution = memoryMgr.GetBestSolution(rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0);
bestSolutionId = solution?.ID;
if (solution == null)
{
completelyRandom = true;
solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, bestSolutionId, ideas);
}
else
{
solutionFound.Solution = solution;
solutionFound.ExistsInCache = true;
}
}
else if (random && outputs.Count() > 1)
{
solution = memoryMgr.GetBestSolution(rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0);
bestSolutionId = solution?.ID;
completelyRandom = true;
solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, bestSolutionId, ideas);
}
else
{
completelyRandom = true;
solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, ideas: ideas);
}
solution = solutionFound.Solution;
}
else // Predict
{
solution = memoryMgr.GetBestSolution(rnn_ins, predict: true, predictLinearTolerance: rnn_net.PredictLinear, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, new List<long>() { neuron.ID }, true);
if (solution == null)
{
completelyRandom = true;
solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, ideas: ideas);
solution = solutionFound.Solution;
#region TODO cousin node search
//// no solution found AND all inputs are Distinct
//if (!hasLinearInputs)
//{
// completelyRandom = true;
// //solution = GetRandomSolutionFromOutput(db, rnn_net.CurrentNetworkID, outputs, false);
// solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs); //GetRandomSolutionFromOutput(db, rnn_net, outputs, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0);
//}
//else // has linear
//{
// // TODO need to change the methods used below to MemoryManager
// //// gets all the known inputs
// //var knownInputs = DetermineKnownInputs(db, rnn_ins, rnn_net.CousinNodeSearchToleranceIncrement);
// //if (knownInputs.Count > 0)
// //{
// // // holds the top cases for each known input
// // var topCases = new List<Case>();
// // foreach (var item in knownInputs)
// // {
// // // gets the top solution for the current input with incremental checks based on the linear bracket
// // var topCase = GetBestKnownCase(db, item, rnn_net.CousinNodeSearchToleranceIncrement);
// // if (topCase != null)
// // {
// // topCases.Add(topCase);
// // }
// // }
// // // determine which Case has the highest score and get it's corresponding solution
// // solution = topCases.OrderByDescending(a => a.Session.DateTimeStop)
// // .ThenByDescending(a => a.CycleEndTime)
// // .ThenByDescending(a => a.CycleScore)
// // .ThenByDescending(a => a.Session.SessionScore)
// // .Take(1)
// // .Select(a => a.Solution)
// // .FirstOrDefault();
// //}
// //else // if no known inputs then we get solution randomly
// //{
// // completelyRandom = true;
// // //solution = GetRandomSolutionFromOutput(db, rnn_net.CurrentNetworkID, outputs, false);
// // solution = GetRandomSolutionFromOutput(db, rnn_net, outputs, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0);
// //}
//}
#endregion
//solutionFound.Solution = solution;
//solutionFound.ExistsInCache = false;
}
else
{
solutionFound.Solution = solution;
solutionFound.ExistsInCache = true;
}
}
//Document score, solution in Case
var newCase = RecordCase(rnn_cyc
, rneuronFound
, rnn_ins
, rnn_outs
, cyclescore
, solutionFound
, 0 //ToDo: Pass the current maturity factor setting
, completelyRandom //ToDo: pass whether or not the result was completely randomly generated
, 0 //ToDo: pass sequential count
);
// set Current case reference
rnn_net.CurrentCase = newCase;
var cycleOutput = new RlmCycleOutput(newCase.ID, newCase.Rneuron_ID, newCase.Solution_ID, rnn_net.Outputs, solution.Output_Values_Solutions);
cycleOutput.CompletelyRandom = completelyRandom;
return(cycleOutput);
}
