public static List <Sample> GenerateSamplesForAllocationProblem(MilkrunBufferAllocationProblem problem, int targetSampleCount = 1000)
{
Console.WriteLine($"Generating training samples for problem={problem} with target sample count of {targetSampleCount}...");
var evaluator = new SimAndRememberEvaluator(problem);
LocalSolverOptimizer.Solve(problem, evaluator, targetSampleCount);
return(evaluator.Samples);
}
public BaseEvaluator(MilkrunBufferAllocationProblem problem)
{
Flc = InstanceGenerator.Generate(1);
for (var i = 0; i < Flc.NumMachines; i++)
{
Flc.Machines[i].ProcessingRate = problem.ProcessingRates[i];
}
}
public static MilkrunBufferAllocationSolution Solve(MilkrunBufferAllocationProblem problem,
BaseProductionRatePredictor predictor, int numIterations, float temp0)
{
Utils.SetSeed(23);
var sw = new Stopwatch();
sw.Start();
var curSol = GenerateStartSolution(problem.ProcessingRates.Count);
var curSolObj = curSol.Costs(problem);
int numAccept = 0, numReject = 0;
var lastPrint = -1;
var printFrequency = 4; // print each 4 seconds
for (var i = 0; i < numIterations; i++)
{
var temp = (float)(temp0 / Math.Log2(i + 2));
var solCandidate = curSol.Copy();
var stepWidth = (int)Math.Round(Math.Max(1.0f, 0.2f * temp));
solCandidate.Move(stepWidth);
var solCandidatePr = solCandidate.ProductionRate(problem, predictor);
Console.WriteLine("Prediction is {0}", solCandidatePr);
if (solCandidatePr >= problem.MinProductionRate)
{
var solCandidateObj = solCandidate.Costs(problem);
if (AcceptanceMetropolis(curSolObj, solCandidateObj, temp))
{
numAccept++;
curSol = solCandidate;
curSolObj = solCandidateObj;
}
else
{
numReject++;
}
}
else
{
numReject++;
}
if (lastPrint == -1 || sw.Elapsed.Seconds - lastPrint > printFrequency)
{
Console.WriteLine(
$"[iter={i}] numAccepted={numAccept}, numRejected={numReject}, bestObj={curSolObj}, stepWidth={stepWidth}, curSol={curSol}");
lastPrint = sw.Elapsed.Seconds;
}
}
sw.Stop();
Console.WriteLine($"Required time in milliseconds = {sw.ElapsedMilliseconds}");
return(curSol.ToMilkrunSolution());
}
public float ProductionRate(MilkrunBufferAllocationProblem problem, BaseProductionRatePredictor predictor)
{
var s = new Sample {
BufferSizes = BufferSizes,
OrderUpToLevels = OrderUpToLevels,
MilkrunCycleLength = MilkRunCycleLength,
ProcessingRates = problem.ProcessingRates
};
return(predictor.Predict(s));
}
public SimAndRememberEvaluator(MilkrunBufferAllocationProblem problem) : base(problem)
{
}
public float Costs(MilkrunBufferAllocationProblem problem)
{
return(1.0f / MilkRunCycleLength * problem.MilkRunInverseCostFactor +
BufferSizes.Select((bufferSize, ix) => bufferSize * problem.BufferCostFactors[ix]).Sum() +
OrderUpToLevels.Select((oul, ix) => oul * problem.OrderUpToCostFactors[ix]).Sum());
}
public static MilkrunBufferAllocationSolution Solve(MilkrunBufferAllocationProblem problem,
BaseEvaluator evaluator,
long iterationLimit = 1000,
bool kerasBased = false)
{
if (evaluator != null && kerasBased)
{
PythonEngine.BeginAllowThreads();
}
using var ls = new localsolver.LocalSolver();
var model = ls.GetModel();
var milkrunCycleLength = model.Int(1, 120);
var orderUpToLevels = Enumerable.Range(0, problem.ProcessingRates.Count).Select(i => model.Int(1, 400))
.ToList();
var bufferSizes = Enumerable.Range(0, problem.BufferCostFactors.Count).Select(i => model.Int(0, 500))
.ToList();
void SetupBoundsForMaterialRatio()
{
for (int i = 0; i < orderUpToLevels.Count; i++)
{
model.AddConstraint(milkrunCycleLength * problem.ProcessingRates[i] >= orderUpToLevels[i]);
model.AddConstraint(milkrunCycleLength * problem.MinProductionRate <= orderUpToLevels[i]);
}
}
void SetupMinimumProductionRateConstraint()
{
var func = model.CreateDoubleExternalFunction(evaluator.Evaluate);
var rateEvalCall = model.Call(func);
rateEvalCall.AddOperand(milkrunCycleLength);
rateEvalCall.AddOperands(orderUpToLevels);
rateEvalCall.AddOperands(bufferSizes);
const float epsilon = 0.005f;
model.Constraint(rateEvalCall >= problem.MinProductionRate + epsilon);
}
void SetupObjectiveFunction()
{
var milkrunCycleCosts = 1.0f / milkrunCycleLength * problem.MilkRunInverseCostFactor;
var bufferCosts = model.Sum(bufferSizes.Select((bsize, ix) => bsize * problem.BufferCostFactors[ix]));
var orderUpToCosts =
model.Sum(orderUpToLevels.Select((level, ix) => level * problem.OrderUpToCostFactors[ix]));
model.Minimize(milkrunCycleCosts + bufferCosts + orderUpToCosts);
}
void SetInitialSolution()
{
bufferSizes.ForEach(bufferSize => bufferSize.SetValue(500));
orderUpToLevels.ForEach(oul => oul.SetValue((int)Math.Ceiling(problem.MinProductionRate * 100.0f)));
milkrunCycleLength.SetValue(100);
}
SetupBoundsForMaterialRatio();
SetupMinimumProductionRateConstraint();
SetupObjectiveFunction();
model.Close();
SetInitialSolution();
//ls.GetParam().SetTimeLimit(10);
ls.GetParam().SetIterationLimit(iterationLimit);
ls.GetParam().SetNbThreads(1);
ls.Solve();
return(new MilkrunBufferAllocationSolution {
BufferSizes = bufferSizes.Select(bufferSize => (int)bufferSize.GetIntValue()).ToList(),
MilkRunCycleLength = (int)milkrunCycleLength.GetIntValue(),
OrderUpToLevels = orderUpToLevels.Select(oul => (int)oul.GetIntValue()).ToList()
});
}
public PredictorBasedEvaluator(MilkrunBufferAllocationProblem problem, BaseProductionRatePredictor predictor) :
base(problem)
{
_predictor = predictor;
}
public PredictorBasedEvaluator(MilkrunBufferAllocationProblem problem, BaseModel model) : base(problem)
{
_predictor = new KerasNeuralProductionRatePredictor(model);
}
public SimulationEvaluator(MilkrunBufferAllocationProblem problem) : base(problem)
{
}