private Int64 Init(RlmNetwork rnn_net, Int64 sessionID, List <RlmIOWithValue> inputs_values, Boolean learn, List <RlmIOWithValue> output_values = null) { if (this.CaseReference != null) { throw new Exception("You may only envoke Runxx once per cycle object."); } // set type of learning based on Inputs and Outputs RlmType = RlmNetworkType.Predict; if (learn) { if ((inputs_values != null && inputs_values.Count > 0) && (output_values != null && output_values.Count > 0)) // Inputs & Outputs { RlmType = RlmNetworkType.Supervised; } else if ((inputs_values != null && inputs_values.Count > 0) && (output_values == null || (output_values != null && output_values.Count == 0))) // Inputs without Outputs { RlmType = RlmNetworkType.Unsupervised; } } Case cyclecase = new Case() { Session_ID = sessionID /*db.Sessions.Where(item=>item.ID == sessionID).First()*/, CycleStartTime = DateTime.Now, CycleEndTime = DateTime.Now }; this.CaseReference = cyclecase; return(cyclecase.ID); }
private RlmCyclecompleteArgs RunCycle(RlmNetwork rnnNet, RlmCycle cycle, List <RlmIOWithValue> inputValues, RlmNetworkType rnnType, List <RlmIOWithValue> outputValues, double cycleScore, IEnumerable <RlmIdea> ideas = null) { //rnn_net._AddCycleToCurrentCycles(this); RlmCycleOutput caseOutput = RlmCerebralCortex.CoreCycleProcess(rnnNet, this, inputValues, RlmType, outputValues, cycleScore, ideas); return(rnnNet.EndCycle(caseOutput, RlmType)); }
/// <summary> /// starts training /// </summary> /// <param name="rnnNet">current network being used</param> /// <param name="sessionID">unique identifier for the session being started</param> /// <param name="inputsValues">Inputs with stored values</param> /// <param name="learn">Indicator that if true, will start training, if false, will run prediction</param> /// <param name="outputValues">Outputs with stored values</param> /// <param name="cyclescore">Score of the current cycle</param> /// <param name="Parallel"></param> /// <param name="ideas">Gives bias to the RLM on what to output</param> /// <returns></returns> public RlmCyclecompleteArgs RunCycle(RlmNetwork rnnNet, Int64 sessionID, List <RlmIOWithValue> inputsValues, Boolean learn, List <RlmIOWithValue> outputValues = null, double cyclescore = 0.000, Boolean Parallel = false, IEnumerable <RlmIdea> ideas = null) { //Run Validity Checks -- includes local var assignment Int64 cyclecaseid = Init(rnnNet, sessionID, inputsValues, learn, outputValues); //if parallel, it is executed on another thread and returns null since the cycle complete arguments can only be taken via the Rnetwork cycle complete event if (Parallel) { cycletask = Task.Run(() => RunCycle(rnnNet, this, inputsValues, RlmType, outputValues, cyclescore, ideas)); return(null); } else //if not parallel, we run it on same thread and return the cycle complete arguments **did it this way for a better windowless training { return(RunCycle(rnnNet, this, inputsValues, RlmType, outputValues, cyclescore, ideas)); } #region Old code commented //cycletask = Task.Run(() => //{ // rnn_net._AddCycleToCurrentCycles(this); // rlm_cycle_output caseOutput = rnn_cerebralcortex.CoreCycleProcess(rnn_net, this, inputs_values, RlmType, output_values, cyclescore); // rnn_net._EndCycle(caseOutput, RlmType); //}); //Non-Parallel Waits for Thread to Complete //if (!Parallel) cycletask.Wait(); #endregion }
private void ClearNetwork() { if (network != null) { network.DataPersistenceComplete -= Network_DataPersistenceComplete; network.Dispose(); network = null; } }
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); }
private IDictionary <int, RlmCyclecompleteArgs> RunOneSession(RlmNetwork network, IEnumerable <KeyValuePair <string, Resource> > resourceInputs, bool learn = true, bool showCycleOutput = false) { CycleOutputs.Clear(); SessionOutputs.Clear(); IDictionary <int, RlmCyclecompleteArgs> cycleOutputDic = new Dictionary <int, RlmCyclecompleteArgs>(); TrainingVariables["SessionScore"].Value = 0; long sessId = network.SessionStart(); List <object> outputList = new List <object>(); //TODO: check later for multiple inputs int min = 0; int max = 0; var resIn = resourceInputs.First(); Resource res = resIn.Value; Dictionary <string, int> inputRange = GetInputRange(res); min = inputRange["Min"]; max = inputRange["Max"]; bool usedExcludeSolutions = false; for (int j = min; j <= max; j++) { RlmCyclecompleteArgs result; List <long> excludeSolutions = null; while (true) { //Populate input values var invs = new List <RlmIOWithValue>(); foreach (var a in network.Inputs) { invs.Add(new RlmIOWithValue(a, j.ToString())); CycleInputs[a.Name] = j; } //Build and run a new RlmCycle var Cycle = new RlmCycle(); result = Cycle.RunCycle(network, sessId, invs, learn, excludeSolutions: excludeSolutions); //TODO: check later for multiple outputs var rlmOut = network.Outputs.First(); var value = result.CycleOutput.Outputs.First(b => b.Name == rlmOut.Name).Value; if (!AllowDuplicates && !learn) { bool hasDup = false; foreach (var rlmOutputs in SessionOutputs) { if (rlmOutputs.Value.Any(a => a.ToString() == value)) { if (excludeSolutions == null) { excludeSolutions = new List <long>(); } excludeSolutions.Add(result.CycleOutput.SolutionID); hasDup = true; System.Diagnostics.Debug.WriteLine("Duplicate found!"); break; } } if (hasDup) { usedExcludeSolutions = true; continue; } } //set current rn and sl cycleOutputDic[j] = result; CycleOutputs[rlmOut.Name] = value; outputList.Add(value); SessionOutputs[rlmOut.Name] = outputList; break; } double cycleScore = ScoreCycle(); if (showCycleOutput) { //if (j == min && PredictData.Count() > min) //{ // PredictData.Clear(); //} //// exposed cyclescore on predict //PredictData.Add(cycleScore.ToString()); } network.ScoreCycle(result.CycleOutput.CycleID, cycleScore); TrainingVariables["CycleScore"].Value = 0; } double sessionScore = ScoreSession(); LastScore = sessionScore; if (LastScore > HighScore) { HighScore = LastScore; } network.SessionEnd(sessionScore); TraceLogObjectsIf(!learn && !usedExcludeSolutions && sessionScore < HighScore, $"{network.DatabaseName}_BestSolutions_InMemory", network.MemoryManager.BestSolutions.SelectMany(a => a.Value.Values)); TraceLog($"Score: {string.Format("{0:n}", sessionScore)}"); // exposed session data //SessionData.Add(sessionScore.ToString()); return(cycleOutputDic); }
public IDictionary <int, RlmCyclecompleteArgs> StartTraining(RlmSettings settings, CancellationToken?token = null) { dataPersistEvent.Reset(); //stopTraining = false; //settings = this.Settings; this.Settings = settings; //Get RLM Settings from user int startRandomness = settings.StartRandomness; int endRandomness = settings.EndRandomness; int maxBracket = settings.MaxLinearBracket; int minBracket = settings.MinLinearBracket; RlmSimulationType simType = settings.SimulationType; TimeSpan time = settings.Time; double target = settings.SimulationTarget; // clear previous network, if any ClearNetwork(); IDictionary <int, RlmCyclecompleteArgs> cycleOutputDic = null; network = (string.IsNullOrEmpty(DatabaseName) ? new RlmNetwork() : new RlmNetwork(RlmDbData, true)); network.DataPersistenceComplete += Network_DataPersistenceComplete; network.StartRandomness = startRandomness; network.EndRandomness = endRandomness; network.MaxLinearBracket = maxBracket; network.MinLinearBracket = minBracket; List <RlmIO> inputs = new List <RlmIO>(); List <RlmIO> outputs = new List <RlmIO>(); //get inputs/outputs from resources var resourceInputs = Resources.Where(a => a.Value.RLMObject == RLMObject.Input); var resourceOutputs = Resources.Where(a => a.Value.RLMObject == RLMObject.Output); //set rlm inputs/outputs inputs = GetRlmIOFromResource(resourceInputs); outputs = GetRlmIOFromResource(resourceOutputs); //create network if (!network.LoadNetwork()) { network.NewNetwork("RlmOptimizer", inputs, outputs); } //start training int sessions = settings.SimulationType == RlmSimulationType.Sessions ? Convert.ToInt32(settings.SimulationTarget) : settings.NumOfSessionsReset; double hours = settings.SimulationType == RlmSimulationType.Time ? settings.Time.TotalHours : 0; DateTime endsOn = DateTime.Now.AddHours(hours); TraceLog($"RLM Settings: \n\n" + $"Randomness: Max = {startRandomness}, End = {endRandomness}\nLinear Bracket: Max = {maxBracket}, Min = {minBracket}\n" + $"Simulation Type: {simType}\nTarget: {target}\nTime: {hours}\n" + $"Cycle Score Formula: {string.Join(" | ", CyclePhase.Formula)}\n" + $"Session Score Formula: {string.Join(" | ", SessionPhase.Formula)}"); TraceLog(); int scoreHits = 0; bool timesUp = false; //for (var trial = 1; trial <= 5; trial++) //{ //TrainingLog($"\nTrial #{trial}"); do { //settings network.NumSessions = sessions; network.StartRandomness = startRandomness; network.EndRandomness = endRandomness; network.MaxLinearBracket = maxBracket; network.MinLinearBracket = minBracket; network.ResetRandomizationCounter(); if ((simType == RlmSimulationType.Time && DateTime.Compare(DateTime.Now, endsOn) == 1) || token?.IsCancellationRequested == true) { timesUp = true; } if (!timesUp) { TraceLog("\nTraining...\n"); for (int i = 1; i <= sessions; i++) { cycleOutputDic = RunOneSession(network, resourceInputs, true); if (settings.SimulationType == RlmSimulationType.Score) { if (UpdateScoreHit(ref scoreHits, settings) || token?.IsCancellationRequested == true) { break; } } if ((simType == RlmSimulationType.Time && DateTime.Compare(DateTime.Now, endsOn) == 1) || token?.IsCancellationRequested == true) { timesUp = true; break; } if (stopTraining || token?.IsCancellationRequested == true) { break; } } } //predict TraceLog("\nPredicting...\n"); if (settings.SimulationType == RlmSimulationType.Score) { for (int i = 1; i <= settings.NumScoreHits; i++) { cycleOutputDic = RunOneSession(network, resourceInputs, false, (i == settings.NumScoreHits)); if (UpdateScoreHit(ref scoreHits, settings) || token?.IsCancellationRequested == true) { break; } } } else { cycleOutputDic = RunOneSession(network, resourceInputs, false, true); } if (stopTraining || token?.IsCancellationRequested == true) { break; } } while ((!timesUp && simType == RlmSimulationType.Time) || (simType == RlmSimulationType.Score && settings.NumScoreHits > scoreHits)); //} //end training network.TrainingDone(); if (simType == RlmSimulationType.Score) { TraceLog($"Score Hits: {scoreHits}"); } TraceLog("Optimization Done"); return(cycleOutputDic); }