public static double[] GetCalculatedWeightedMetricArray(Item item, RPOCSimpleSimSettings simSettings) { double[] retVal = new double[5]; // we go through each attribute for the item and sum up each of its metric foreach (var attr in item.Attributes) { retVal[0] += attr.Metric1; retVal[1] += attr.Metric2; retVal[2] += attr.Metric3; retVal[3] += attr.Metric4; retVal[4] += attr.Metric5; //retVal[5] += attr.Metric6; //retVal[6] += attr.Metric7; //retVal[7] += attr.Metric8; //retVal[8] += attr.Metric9; //retVal[9] += attr.Metric10; } // with the retVal all summed up, we then get the percentage (based on the ones set in SimulationSettings) so we can get its weight retVal retVal[0] = simSettings.Metric1 == 0 ? 0 : retVal[0] * (simSettings.Metric1 / 100D); retVal[1] = simSettings.Metric2 == 0 ? 0 : retVal[1] * (simSettings.Metric2 / 100D); retVal[2] = simSettings.Metric3 == 0 ? 0 : retVal[2] * (simSettings.Metric3 / 100D); retVal[3] = simSettings.Metric4 == 0 ? 0 : retVal[3] * (simSettings.Metric4 / 100D); retVal[4] = simSettings.Metric5 == 0 ? 0 : retVal[4] * (simSettings.Metric5 / 100D); //retVal[5] = simSettings.Metric6 == 0 ? 0 : retVal[5] * (simSettings.Metric6 / 100D); //retVal[6] = simSettings.Metric7 == 0 ? 0 : retVal[6] * (simSettings.Metric7 / 100D); //retVal[7] = simSettings.Metric8 == 0 ? 0 : retVal[7] * (simSettings.Metric8 / 100D); //retVal[8] = simSettings.Metric9 == 0 ? 0 : retVal[8] * (simSettings.Metric9 / 100D); //retVal[9] = simSettings.Metric10 == 0 ? 0 : retVal[9] * (simSettings.Metric10 / 100D); return(retVal); }
// Set values to metric sliders public void SetMetricSliderValues(RPOCSimpleSimSettings settings) { this.metricSlider1.Value = settings.Metric1; // for metric1 slider this.metricSlider2.Value = settings.Metric2; // for metric2 slider this.metricSlider3.Value = settings.Metric3; // for metric3 slider this.metricSlider4.Value = settings.Metric4; // for metric4 slider this.metricSlider5.Value = settings.Metric5; // for metric5 slider // Storing values setMetricValues(); }
/// <summary> /// Instantiates a new instance of the plangoram optimizer /// </summary> /// <param name="items">The dataset (items with their attributes and metrics) for the RLM to learn from</param> /// <param name="simSettings">Holds data which dictates what type of simulation to run and for how long. Also holds the weights metrics and other general settings</param> /// <param name="updateUI">Callback function for sending the results of the optimization for each session</param> /// <param name="updateStatus">Callback function for sending the current status of the RLM</param> /// <param name="logger">Logs the per session stats and allows users to download the CSV file after the training</param> /// <remarks>Used a callback instead of an event because we worry that the display might not keep up with the optimization. You can disable the display by setting it in the Simulation panel</remarks> public PlanogramOptimizer(Item[] items, RPOCSimpleSimSettings simSettings, UpdateUICallback updateUI = null, UpdateStatusCallback updateStatus = null, SimulationCsvLogger logger = null, string dbIdentifier = null, DataPersistenceProgressDelegate dataPersistProgress = null) { IsTrainingDone = false; this.logger = logger; this.items = items.ToArray(); this.simSettings = simSettings; UpdateUI = updateUI; UpdateStatus = updateStatus; if (ENABLE_RLM_OUTPUT_LIMITER) { currentItemIndexes = new List <int>(); } UpdateStatus?.Invoke("Initializing..."); // creates the network (and the underlying DB) with a unique name to have a different network everytime you run a simulation IRlmDbData rlmDbData = new RlmDbDataSQLServer(dbIdentifier != null ? dbIdentifier : "RLM_planogram_" + Guid.NewGuid().ToString("N")); //IRlmDbData rlmDbData = new RlmDbDataPostgreSqlServer(dbIdentifier != null ? dbIdentifier : "RLM_planogram_" + Guid.NewGuid().ToString("N")); network = new RlmNetwork(rlmDbData); if (dataPersistProgress != null) { network.DataPersistenceProgress += dataPersistProgress; } // checks if the network structure already exists // if not then we proceed to define the inputs and outputs inputType = RLM.Enums.RlmInputType.Distinct; if (!network.LoadNetwork("planogram")) { string int32Type = typeof(Int32).ToString(); var inputs = new List <RlmIO>(); //inputs.Add(new RlmIO() { Name = "Shelf", DotNetType = int32Type, Min = 1, Max = simSettings.NumShelves, Type = RLM.Enums.RlmInputType.Linear }); inputs.Add(new RlmIO() { Name = "Slot", DotNetType = int32Type, Min = 1, Max = simSettings.NumSlots * simSettings.NumShelves, Type = inputType }); var outputs = new List <RlmIO>(); outputs.Add(new RlmIO() { Name = "Item", DotNetType = int32Type, Min = 0, Max = this.items.Length - 1 }); // change Max to any number above 1 (and must not be go beyond the NumSlots value) to have multiple facings //outputs.Add(new RlmIO() { Name = "NumFacings", DotNetType = int32Type, Min = 1, Max = 1 }); // creates the network network.NewNetwork("planogram", inputs, outputs); } }
/// <summary> /// Calculates the metric for an item based on the attributes it has been assigned /// </summary> /// <param name="item">The item reference with its attributes</param> /// <returns>The calculated metric</returns> public static double GetCalculatedWeightedMetrics(Item item, RPOCSimpleSimSettings simSettings) { double retVal = 0; double[] metrics = GetCalculatedWeightedMetricArray(item, simSettings); // now having the weighted metrics calculated we simply sum it all up to get a single metric used to score the item retVal = metrics.Sum(); return(retVal); }
public double GetItemMinimumScore(RPOCSimpleSimSettings simSettings) { double retVal = double.MinValue; //retVal = context.Database.SqlQuery<double>(@" // select // min(m1 + m2 + m3 + m4 + m5) // from ( // select // a.ID, // iif(@p0 = 0, 0, sum(c.Metric1) * (@p0 / 100)) m1, // iif(@p1 = 0, 0, sum(c.Metric2) * (@p1 / 100)) m2, // iif(@p2 = 0, 0, sum(c.Metric3) * (@p2 / 100)) m3, // iif(@p3 = 0, 0, sum(c.Metric4) * (@p3 / 100)) m4, // iif(@p4 = 0, 0, sum(c.Metric5) * (@p4 / 100)) m5 // from Items a // inner join ItemAttributes b on a.ID = b.Item_ID // inner join Attributes c on b.Attributes_ID = c.ID // group by a.ID // ) a // ", simSettings.Metric1, simSettings.Metric2, simSettings.Metric3, simSettings.Metric4, simSettings.Metric5).FirstOrDefault(); List <double> metricScores = new List <double>(); foreach (var item in items) { double metric1 = simSettings.Metric1 == 0 ? 0 : item.Attributes.Select(a => a.Metric1).Sum() * (simSettings.Metric1 / 100); double metric2 = simSettings.Metric2 == 0 ? 0 : item.Attributes.Select(a => a.Metric2).Sum() * (simSettings.Metric2 / 100); double metric3 = simSettings.Metric3 == 0 ? 0 : item.Attributes.Select(a => a.Metric3).Sum() * (simSettings.Metric3 / 100); double metric4 = simSettings.Metric4 == 0 ? 0 : item.Attributes.Select(a => a.Metric4).Sum() * (simSettings.Metric4 / 100); double metric5 = simSettings.Metric5 == 0 ? 0 : item.Attributes.Select(a => a.Metric5).Sum() * (simSettings.Metric5 / 100); double metrics = metric1 + metric2 + metric3 + metric4 + metric5; metricScores.Add(metrics); } return(metricScores.Min()); }
public void SetSimSettings(RPOCSimpleSimSettings simSettings) { if (simSettings != null) { this.simSettings = simSettings; SimType = simSettings.SimType; Sessions = simSettings.Sessions; Hours = simSettings.Hours; Score = simSettings.Score; chkSimDisplay.IsChecked = simSettings.EnableSimDisplay; calculateMaxScore(); simScoreSlider.Value = simSettings.DefaultScorePercentage; simScoreSliderLbl.Content = simScoreSlider.Value + "%"; switch (SimType) { case SimulationType.Sessions: rdbSessions.IsChecked = true; txtSimInput.Text = Sessions.ToString(); showScoreSlider(false); break; case SimulationType.Time: rdbTime.IsChecked = true; txtSimInput.Text = Hours.ToString(); showScoreSlider(false); break; default: rdbScore.IsChecked = true; txtSimInput.Text = Score.ToString(); showScoreSlider(true); break; } } }
public double GetItemMaxScoreForTop(RPOCSimpleSimSettings simSettings) { double retVal = 0; int numSlots = simSettings.NumShelves * simSettings.NumSlots; double top = Math.Ceiling(Convert.ToDouble(numSlots) / Convert.ToDouble(RPOCSimpleSimSettings.MAX_ITEMS)); //var topItems = context.Database.SqlQuery<double>($@" // select top {top} // (m1 + m2 + m3 + m4 + m5) as Score // from ( // select // a.ID, // iif(@p0 = 0, 0, sum(c.Metric1) * (@p0 / 100)) m1, // iif(@p1 = 0, 0, sum(c.Metric2) * (@p1 / 100)) m2, // iif(@p2 = 0, 0, sum(c.Metric3) * (@p2 / 100)) m3, // iif(@p3 = 0, 0, sum(c.Metric4) * (@p3 / 100)) m4, // iif(@p4 = 0, 0, sum(c.Metric5) * (@p4 / 100)) m5 // from Items a // inner join ItemAttributes b on a.ID = b.Item_ID // inner join Attributes c on b.Attributes_ID = c.ID // group by a.ID // ) a // order by Score desc // " // , simSettings.Metric1, simSettings.Metric2, simSettings.Metric3, simSettings.Metric4, simSettings.Metric5).ToList(); List <double> metricScores = new List <double>(); foreach (var item in Items) { double metric1 = simSettings.Metric1 == 0 ? 0 : item.Attributes.Select(a => a.Metric1).Sum() * (simSettings.Metric1 / 100); double metric2 = simSettings.Metric2 == 0 ? 0 : item.Attributes.Select(a => a.Metric2).Sum() * (simSettings.Metric2 / 100); double metric3 = simSettings.Metric3 == 0 ? 0 : item.Attributes.Select(a => a.Metric3).Sum() * (simSettings.Metric3 / 100); double metric4 = simSettings.Metric4 == 0 ? 0 : item.Attributes.Select(a => a.Metric4).Sum() * (simSettings.Metric4 / 100); double metric5 = simSettings.Metric5 == 0 ? 0 : item.Attributes.Select(a => a.Metric5).Sum() * (simSettings.Metric5 / 100); double metrics = metric1 + metric2 + metric3 + metric4 + metric5; metricScores.Add(metrics); } int atop = Convert.ToInt32(top); List <double> topItems = metricScores.OrderByDescending(a => a).Take(atop).ToList(); int slotsAccountedFor = 0; for (int i = 0; i < topItems.Count; i++) { if (slotsAccountedFor + 1 >= numSlots) { var remaining = numSlots - slotsAccountedFor; topItems[i] = topItems[i] * remaining; } else { slotsAccountedFor += 1; topItems[i] = topItems[i] * 1; } } retVal = topItems.Sum(); return(retVal); }