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);
}
