/// <summary> /// Starts optimization based on the array of items and simulation setting that were passed in during instantiation /// </summary> /// <returns>The final (predicted) output of the optimization</returns> public PlanogramOptResults StartOptimization(CancellationToken?cancelToken = null) { UpdateStatus?.Invoke("Training..."); var retVal = new PlanogramOptResults(); // checks what type of simulation we are running int sessions = simSettings.SimType == SimulationType.Sessions ? simSettings.Sessions.Value : DEFAULT_SESSIONS_PER_BATCH; double hours = simSettings.SimType == SimulationType.Time ? simSettings.Hours.Value : 0; simSettings.StartedOn = DateTime.Now; simSettings.EndsOn = DateTime.Now.AddHours(hours); // simulation scenarios: // if we are doing SimulationType.Sessions then the do-while loop will fail, just does the codeblock once, and trains the network with the specific number of sessions // if we are doing SimulationType.Time then as default it will train for 100 sessions at a time (per loop) and continues to do so until time runs out // if we are doing SimulationType.Score then it will execute just like the Time option except that it will continue to do so until the specified Score is met or surpassed do { // settings network.NumSessions = sessions; // you can change this and start experimenting which range is best // NOTE if you decide to have multiple facings (by changing the NumFacings output Max to greater than 1) and enforce item uniqueness then the EndRandomness must not be 0 (i suggest 5 as the minimum) // as the planogram needs a bit of randomness towards the end since we have a condition where we enforce uniqueness of items. In the event that the RLM outputs an item that // is already in the planogram then having enough randomness left will allow it to still have a chance to suggest a different item otherwise the RLM will suggest the same item over and over again and cause an infinite loop network.StartRandomness = START_RANDOMNESS; network.EndRandomness = END_RANDOMNESS; //(simSettings.SimType == SimulationType.Sessions) ? 0 : network.StartRandomness; //network.MaxLinearBracket = MAX_LINEAR; //network.MinLinearBracket = MIN_LINEAR; // since we might be retraining the network (i.e, SimulationType.Time or Score), we need to call this method to reset the randomization counter of the RLM network.ResetRandomizationCounter(); // training, train 90% per session batch if not Session Type var trainingTimes = (simSettings.SimType == SimulationType.Sessions) ? sessions : sessions - PREDICT_SESSIONS; retVal = Optimize(trainingTimes, true, simSettings.EnableSimDisplay); if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested) { return(retVal); } // for non Sessions type, we predict {PREDICT_SESSIONS}-times per session batch if (simSettings.SimType != SimulationType.Sessions) { int predictTimes = PREDICT_SESSIONS; if (simSettings.SimType == SimulationType.Score && predictTimes < RPOCSimulationSettings.NUM_SCORE_HITS) { predictTimes = RPOCSimulationSettings.NUM_SCORE_HITS; } retVal = Optimize(predictTimes, false, simSettings.EnableSimDisplay); } } while ((simSettings.SimType == SimulationType.Time && simSettings.EndsOn > DateTime.Now) || (simSettings.SimType == SimulationType.Score && RPOCSimulationSettings.NUM_SCORE_HITS > numScoreHits)); // we do a final prediction and to ensure we update the plangoram display for the final output retVal = Optimize(1, false, true); network.TrainingDone(); UpdateStatus?.Invoke("Done", true); return(retVal); }
public void ResetRLM() { network.ResetRandomizationCounter(); }
static void Main(string[] args) { Console.WriteLine("XOR"); Console.WriteLine("\nRLM settings"); // user inputs for the RLM settings int sessions = Util.GetInput("Number of sessions [default 50]: ", 50); int startRandomness = Util.GetInput("Start randomness [default 50]: ", 50); int endRandomness = Util.GetInput("End randomness [default 0]: ", 0); // use Sql Server as Rlm Db IRlmDbData rlmDBData = new RlmDbDataSQLServer($"RLM_XOR_SAMPLE_{Guid.NewGuid().ToString("N")}"); //IRlmDbData rlmDBData = new RlmDbDataPostgreSqlServer($"RLM_XOR_SAMPLE_{Guid.NewGuid().ToString("N")}"); // the appended Guid is just to have a unique RLM network every time we run this example. // you can remove this or simply change the name to something static to use the same network all the time var rlmNet = new RlmNetwork(rlmDBData); // subscribe to events to know the status of the Data Persistence that works in the background rlmNet.DataPersistenceComplete += RlmNet_DataPersistenceComplete; rlmNet.DataPersistenceProgress += RlmNet_DataPersistenceProgress; // checks to see if the network already exists and loads it to memory if (!rlmNet.LoadNetwork("XOR_SAMPLE")) { // declare our inputs var ins = new List <RlmIO>(); ins.Add(new RlmIO("XORInput1", typeof(bool).ToString(), 0, 1, RlmInputType.Distinct)); ins.Add(new RlmIO("XORInput2", typeof(bool).ToString(), 0, 1, RlmInputType.Distinct)); // declare our outputs var outs = new List <RlmIO>(); outs.Add(new RlmIO("XOROutput", typeof(bool).ToString(), 0, 1)); // creates a new network rlmNet.NewNetwork("XOR_SAMPLE", ins, outs); } // execute it on another thread as not to block the RLM training Console.WriteLine("\nPress 'd' to show Data persistence progress\n"); Task.Run(() => { while (!Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.D) { showDataPersistProgress = true; } }); // set rlm training settings rlmNet.NumSessions = sessions; rlmNet.StartRandomness = startRandomness; rlmNet.EndRandomness = endRandomness; Console.WriteLine("Training Session started"); double sumOfCycleScores = 0; // this is just good practice, usually you need to call this when you want to do multiple trainings on the same network over and over again. // it resets the randomization of the RLM back to the beginning (start randomness) after each training set // i.e, training for 50 sessions, then training for another 50 sessions, and so on and so forth rlmNet.ResetRandomizationCounter(); for (int i = 0; i < sessions; i++) { // start session long sessionId = rlmNet.SessionStart(); sumOfCycleScores = 0; foreach (var xor in xorTable) { //Populate input values var invs = new List <RlmIOWithValue>(); // get value for Input1 and associate it with the Input instance string input1Value = xor.Input1; invs.Add(new RlmIOWithValue(rlmNet.Inputs.Where(item => item.Name == "XORInput1").First(), input1Value)); // get value for Input2 and associate it with the Input instance string input2Value = xor.Input2; invs.Add(new RlmIOWithValue(rlmNet.Inputs.Where(item => item.Name == "XORInput2").First(), input2Value)); //Build and run a new RlmCycle var Cycle = new RlmCycle(); RlmCyclecompleteArgs result = Cycle.RunCycle(rlmNet, sessionId, invs, true); // scores the RLM on how well it did for this cycle // each cycle with a correct output is rewarded a 100 score, 0 otherwise double score = ScoreCycle(result, xor); sumOfCycleScores += score; // sets the score rlmNet.ScoreCycle(result.CycleOutput.CycleID, score); } Console.WriteLine($"Session #{i} - score: {sumOfCycleScores}"); // end the session with the sum of the cycle scores // with the way the scoring is set, a perfect score would be 400 meaning all cycles got it right rlmNet.SessionEnd(sumOfCycleScores); } Console.WriteLine("Training Session ended"); Console.WriteLine(); Console.WriteLine("Predict:"); // PREDICT... see how well the RLM learned // NOTE that the only difference with Predict from Training is that we passed 'false' to the learn argument on the Cycle.RunCycle() method // and of course, the inputs which we used our xor table to check if the RLM has learned as expected long SessionID = rlmNet.SessionStart(); sumOfCycleScores = 0; foreach (var xor in xorTable) { var invs = new List <RlmIOWithValue>(); invs.Add(new RlmIOWithValue(rlmNet.Inputs.First(a => a.Name == "XORInput1"), xor.Input1)); invs.Add(new RlmIOWithValue(rlmNet.Inputs.First(a => a.Name == "XORInput2"), xor.Input2)); RlmCycle Cycle = new RlmCycle(); RlmCyclecompleteArgs result = Cycle.RunCycle(rlmNet, SessionID, invs, false); double score = ScoreCycle(result, xor, true); sumOfCycleScores += score; // sets the score rlmNet.ScoreCycle(result.CycleOutput.CycleID, score); } rlmNet.SessionEnd(sumOfCycleScores); // must call this to let the Data persistence know we are done training/predicting rlmNet.TrainingDone(); Console.ReadLine(); }
public void ResetRLMRandomization() { rlmNet.ResetRandomizationCounter(); }