public double GetItemMaximumScore(RPOCSimulationSettings simSettings)
{
double retVal = double.MinValue;
retVal = _context.Database.SqlQuery <double>(@"
select
max(m1 + m2 + m3 + m4 + m5 + m6 + m7 + m8 + m9 + m10)
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,
iif(@p5 = 0, 0, sum(c.Metric6) * (@p5 / 100)) m6,
iif(@p6 = 0, 0, sum(c.Metric7) * (@p6 / 100)) m7,
iif(@p7 = 0, 0, sum(c.Metric8) * (@p7 / 100)) m8,
iif(@p8 = 0, 0, sum(c.Metric9) * (@p8 / 100)) m9,
iif(@p9 = 0, 0, sum(c.Metric10) * (@p9 / 100)) m10
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, simSettings.Metric6, simSettings.Metric7, simSettings.Metric8, simSettings.Metric9, simSettings.Metric10).FirstOrDefault();
return(retVal);
}
public PlanogramOptimizerEncog(Item[] items, RPOCSimulationSettings simSettings, UpdateUINonRLMCallback updateUI = null, UpdateStatusCallback updateStatus = null, SimulationCsvLogger logger = null, bool anneal = true)
{
updateStatus?.Invoke("Initializing...");
//this.items = items;
this.simSettings = simSettings;
this.logger = logger;
this.updateUI = updateUI;
this.updateStatus = updateStatus;
network = CreateNetwork();
planogramScore = new PlanogramScore()
{
SimSettings = simSettings,
Items = items,
UpdateUI = updateUI,
Logger = logger
};
if (anneal)
{
train = new NeuralSimulatedAnnealing(network, planogramScore, 10, 2, (simSettings.SimType == SimulationType.Sessions) ? 1 : 10); // todo make the # of cycles an input for users?
}
else
{
train = new MLMethodGeneticAlgorithm(() => {
((IMLResettable)network).Reset();
return(network);
}, planogramScore, 500);
}
}
public static double[] GetCalculatedWeightedMetricArray(Item item, RPOCSimulationSettings simSettings)
{
double[] retVal = new double[10];
// 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);
}
public PlanogramSimulation(BasicNetwork network, Item[] items, RPOCSimulationSettings simSettings)
{
slotNormalizer = new NormalizedField(NormalizationAction.Normalize, "Slot", (simSettings.NumSlots * simSettings.NumShelves) - 1, 0, -1, 1);
itemNormalizer = new NormalizedField(NormalizationAction.Normalize, "Item", items.Length - 1, 0, -1, 1);
this.items = items;
this.simSettings = simSettings;
this.network = network;
}
/// <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, RPOCSimulationSettings 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);
}
// Set values to metric sliders
public void SetMetricSliderValues(RPOCSimulationSettings settings)
{
var selectedMetrics = GetIncludedMetrics();
foreach (var m in selectedMetrics)
{
switch (m.Key)
{
case "Metric1":
this.metricSlider1.Value = settings.Metric1; // for metric1 slider
break;
case "Metric2":
this.metricSlider2.Value = settings.Metric2; // for metric2 slider
break;
case "Metric3":
this.metricSlider3.Value = settings.Metric3; // for metric3 slider
break;
case "Metric4":
this.metricSlider4.Value = settings.Metric4; // for metric4 slider
break;
case "Metric5":
this.metricSlider5.Value = settings.Metric5; // for metric5 slider
break;
case "Metric6":
this.metricSlider6.Value = settings.Metric6; // for metric6 slider
break;
case "Metric7":
this.metricSlider7.Value = settings.Metric7; // for metric7 slider
break;
case "Metric8":
this.metricSlider8.Value = settings.Metric8; // for metric8 slider
break;
case "Metric9":
this.metricSlider9.Value = settings.Metric9; // for metric9 slider
break;
case "Metric10":
this.metricSlider10.Value = settings.Metric10; // for metric10 slider
break;
}
}
// Storing values
setMetricValues();
}
public double GetItemMaxScoreForTop(RPOCSimulationSettings simSettings)
{
double retVal = 0;
int numSlots = simSettings.NumShelves * simSettings.NumSlots;
double top = Math.Ceiling(Convert.ToDouble(numSlots) / Convert.ToDouble(RPOCSimulationSettings.MAX_ITEMS));
var topItems = _context.Database.SqlQuery <double>($@"
select top {top}
(m1 + m2 + m3 + m4 + m5 + m6 + m7 + m8 + m9 + m10) 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,
iif(@p5 = 0, 0, sum(c.Metric6) * (@p5 / 100)) m6,
iif(@p6 = 0, 0, sum(c.Metric7) * (@p6 / 100)) m7,
iif(@p7 = 0, 0, sum(c.Metric8) * (@p7 / 100)) m8,
iif(@p8 = 0, 0, sum(c.Metric9) * (@p8 / 100)) m9,
iif(@p9 = 0, 0, sum(c.Metric10) * (@p9 / 100)) m10
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, simSettings.Metric6, simSettings.Metric7, simSettings.Metric8, simSettings.Metric9, simSettings.Metric10).ToList();
int slotsAccountedFor = 0;
for (int i = 0; i < topItems.Count; i++)
{
if (slotsAccountedFor + 10 >= numSlots)
{
var remaining = numSlots - slotsAccountedFor;
topItems[i] = topItems[i] * remaining;
}
else
{
slotsAccountedFor += 10;
topItems[i] = topItems[i] * 10D;
}
}
retVal = topItems.Sum();
return(retVal);
}
public void SetSimSettings(RPOCSimulationSettings simSettings)
{
if (simSettings != null)
{
this.simSettings = simSettings;
SimType = simSettings.SimType;
Sessions = simSettings.Sessions;
Hours = simSettings.Hours;
Score = simSettings.Score;
chkSimDisplay.IsChecked = simSettings.EnableSimDisplay;
if (!simSettings.EncogSelected)
{
grpEncogSettings.Visibility = Visibility.Collapsed;
this.Height -= grpEncogSettings.Height;
}
else
{
HiddenLayers = simSettings.HiddenLayers;
txtHiddenLayers.Text = HiddenLayers.ToString();
HiddenLayerNeurons = (simSettings.HiddenLayerNeurons <= 0) ? simSettings.NumSlots * simSettings.NumShelves : simSettings.HiddenLayerNeurons;
txtHiddenLayerNeurons.Text = HiddenLayerNeurons.ToString();
}
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;
}
}
}
// Set values to metric sliders
public void SetMetricSliderValues(RPOCSimulationSettings 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
this.metricSlider6.Value = settings.Metric6; // for metric6 slider
this.metricSlider7.Value = settings.Metric7; // for metric7 slider
this.metricSlider8.Value = settings.Metric8; // for metric8 slider
this.metricSlider9.Value = settings.Metric9; // for metric9 slider
this.metricSlider10.Value = settings.Metric10; // for metric10 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, RPOCSimulationSettings simSettings, UpdateUICallback updateUI = null, UpdateStatusCallback updateStatus = null, SimulationCsvLogger logger = null, string dbIdentifier = null)
{
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 RlmDbDataPostgreSqlServer(dbIdentifier != null ? dbIdentifier : "RLM_planogram_" + Guid.NewGuid().ToString("N"));
IRlmDbData rlmDbData = new RlmDbDataSQLServer(dbIdentifier != null ? dbIdentifier : "RLM_planogram_" + Guid.NewGuid().ToString("N"));
network = new RlmNetwork(rlmDbData);
network.DataPersistenceComplete += Network_DataPersistenceComplete;
// 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);
}
}
public SimulationSetter(RPOCSimulationSettings simSettings)
{
this.simSettings = simSettings;
}