sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Changed statistics output a little. Optimized the case where the transition matrix of the epoch model is empty

main
TimQu 8 years ago
parent
23686a0f09
commit
108e8e69e8
4 changed files with 184 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 283
      src/storm/modelchecker/multiobjective/pcaa/SparseMdpRewardBoundedPcaaWeightVectorChecker.cpp
  2. 18
      src/storm/modelchecker/multiobjective/pcaa/SparseMdpRewardBoundedPcaaWeightVectorChecker.h
  3. 16
      src/storm/modelchecker/multiobjective/rewardbounded/MultiDimensionalRewardUnfolding.cpp
  4. 18
      src/storm/modelchecker/multiobjective/rewardbounded/MultiDimensionalRewardUnfolding.h

283
src/storm/modelchecker/multiobjective/pcaa/SparseMdpRewardBoundedPcaaWeightVectorChecker.cpp
View File

@ -85,136 +85,200 @@ namespace storm {
template <class SparseMdpModelType>
void SparseMdpRewardBoundedPcaaWeightVectorChecker<SparseMdpModelType>::computeEpochSolution(typename MultiDimensionalRewardUnfolding<ValueType, false>::Epoch const& epoch, std::vector<ValueType> const& weightVector, EpochCheckingData& cachedData) {
auto& epochModel = rewardUnfolding.setCurrentEpoch(epoch);
updateCachedData(epochModel, cachedData, weightVector);
++numCheckedEpochs;
swEqBuilding.start();
++numCheckedEpochs;
swEpochModelBuild.start();
auto& epochModel = rewardUnfolding.setCurrentEpoch(epoch);
swEpochModelBuild.stop();
swEpochModelAnalysis.start();
std::vector<typename MultiDimensionalRewardUnfolding<ValueType, false>::SolutionType> result;
result.reserve(epochModel.epochInStates.getNumberOfSetBits());
uint64_t solutionSize = this->objectives.size() + 1;
// Formulate a min-max equation system max(A*x+b)=x for the weighted sum of the objectives
swAux1.start();
assert(cachedData.bMinMax.capacity() >= epochModel.epochMatrix.getRowCount());
assert(cachedData.xMinMax.size() == epochModel.epochMatrix.getRowGroupCount());
cachedData.bMinMax.assign(epochModel.epochMatrix.getRowCount(), storm::utility::zero<ValueType>());
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
ValueType weight = storm::solver::minimize(this->objectives[objIndex].formula->getOptimalityType()) ? -weightVector[objIndex] : weightVector[objIndex];
if (!storm::utility::isZero(weight)) {
std::vector<ValueType> const& objectiveReward = epochModel.objectiveRewards[objIndex];
for (auto const& choice : epochModel.objectiveRewardFilter[objIndex]) {
cachedData.bMinMax[choice] += weight * objectiveReward[choice];
// If the epoch matrix is empty we do not need to solve linear equation systems
if (epochModel.epochMatrix.getEntryCount() == 0) {
std::vector<ValueType> weights = weightVector;
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
if (storm::solver::minimize(this->objectives[objIndex].formula->getOptimalityType())) {
weights[objIndex] *= -storm::utility::one<ValueType>();
}
}
}
auto stepSolutionIt = epochModel.stepSolutions.begin();
for (auto const& choice : epochModel.stepChoices) {
cachedData.bMinMax[choice] += stepSolutionIt->front();
++stepSolutionIt;
}
swAux1.stop();
// Invoke the min max solver
swEqBuilding.stop();
swMinMaxSolving.start();
cachedData.minMaxSolver->solveEquations(cachedData.xMinMax, cachedData.bMinMax);
swMinMaxSolving.stop();
swEqBuilding.start();
for (auto const& state : epochModel.epochInStates) {
result.emplace_back();
result.back().reserve(solutionSize);
result.back().push_back(cachedData.xMinMax[state]);
}
// Check whether the linear equation solver needs to be updated
auto const& choices = cachedData.minMaxSolver->getSchedulerChoices();
if (cachedData.schedulerChoices != choices) {
std::vector<uint64_t> choicesTmp = choices;
cachedData.minMaxSolver->setInitialScheduler(std::move(choicesTmp));
swAux2.start();
++numSchedChanges;
cachedData.schedulerChoices = choices;
storm::solver::GeneralLinearEquationSolverFactory<ValueType> linEqSolverFactory;
bool needEquationSystem = linEqSolverFactory.getEquationProblemFormat() == storm::solver::LinearEquationSolverProblemFormat::EquationSystem;
storm::storage::SparseMatrix<ValueType> subMatrix = epochModel.epochMatrix.selectRowsFromRowGroups(choices, needEquationSystem);
if (needEquationSystem) {
subMatrix.convertToEquationSystem();
}
cachedData.linEqSolver = linEqSolverFactory.create(std::move(subMatrix));
cachedData.linEqSolver->setCachingEnabled(true);
swAux2.stop();
}
// Formulate for each objective the linear equation system induced by the performed choices
swAux3.start();
assert(cachedData.bLinEq.size() == choices.size());
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
auto const& obj = this->objectives[objIndex];
std::vector<ValueType> const& objectiveReward = epochModel.objectiveRewards[objIndex];
auto rowGroupIndexIt = epochModel.epochMatrix.getRowGroupIndices().begin();
auto choiceIt = choices.begin();
auto stepChoiceIt = epochModel.stepChoices.begin();
auto stepSolutionIt = epochModel.stepSolutions.begin();
std::vector<ValueType>& x = cachedData.xLinEq[objIndex];
auto xIt = x.begin();
for (auto& b_i : cachedData.bLinEq) {
uint64_t i = *rowGroupIndexIt + *choiceIt;
if (epochModel.objectiveRewardFilter[objIndex].get(i)) {
b_i = objectiveReward[i];
} else {
b_i = storm::utility::zero<ValueType>();
}
while (*stepChoiceIt < i) {
++stepChoiceIt;
++stepSolutionIt;
}
if (i == *stepChoiceIt) {
b_i += (*stepSolutionIt)[objIndex + 1];
++stepChoiceIt;
++stepSolutionIt;
auto stepChoiceIt = epochModel.stepChoices.begin();
for (auto const& state : epochModel.epochInStates) {
// Obtain the best choice for this state according to the weighted combination of objectives
ValueType bestValue;
uint64_t bestChoice = std::numeric_limits<uint64_t>::max();
auto bestChoiceStepSolutionIt = epochModel.stepSolutions.end();
uint64_t lastChoice = epochModel.epochMatrix.getRowGroupIndices()[state + 1];
bool firstChoice = true;
for (uint64_t choice = epochModel.epochMatrix.getRowGroupIndices()[state]; choice < lastChoice; ++choice) {
ValueType choiceValue = storm::utility::zero<ValueType>();
// Obtain the (weighted) objective rewards
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
if (epochModel.objectiveRewardFilter[objIndex].get(choice)) {
choiceValue += weights[objIndex] * epochModel.objectiveRewards[objIndex][choice];
}
}
// Obtain the step solution if this is a step choice
while (*stepChoiceIt < choice) {
++stepChoiceIt;
++stepSolutionIt;
}
if (*stepChoiceIt == choice) {
choiceValue += stepSolutionIt->front();
// Check if this choice is better
if (firstChoice || choiceValue > bestValue) {
bestValue = std::move(choiceValue);
bestChoice = choice;
bestChoiceStepSolutionIt = stepSolutionIt;
}
} else if (firstChoice || choiceValue > bestValue) {
bestValue = std::move(choiceValue);
bestChoice = choice;
bestChoiceStepSolutionIt = epochModel.stepSolutions.end();
}
firstChoice = false;
}
// We can already set x_i correctly if row i is empty.
// Appearingly, some linear equation solvers struggle to converge otherwise.
if (epochModel.epochMatrix.getRow(i).getNumberOfEntries() == 0) {
*xIt = b_i;
// Insert the solution w.r.t. this choice
result.emplace_back();
result.back().reserve(solutionSize);
result.back().push_back(std::move(bestValue));
if (bestChoiceStepSolutionIt != epochModel.stepSolutions.end()) {
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
if (epochModel.objectiveRewardFilter[objIndex].get(bestChoice)) {
result.back().push_back((epochModel.objectiveRewards[objIndex][bestChoice] + (*bestChoiceStepSolutionIt)[objIndex + 1]));
} else {
result.back().push_back((*bestChoiceStepSolutionIt)[objIndex + 1]);
}
}
} else {
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
if (epochModel.objectiveRewardFilter[objIndex].get(bestChoice)) {
result.back().push_back((epochModel.objectiveRewards[objIndex][bestChoice]));
} else {
result.back().push_back(storm::utility::zero<ValueType>());
}
}
}
++xIt;
++rowGroupIndexIt;
++choiceIt;
}
assert(x.size() == choices.size());
auto req = cachedData.linEqSolver->getRequirements();
cachedData.linEqSolver->clearBounds();
if (obj.lowerResultBound) {
req.clearLowerBounds();
cachedData.linEqSolver->setLowerBound(*obj.lowerResultBound);
} else {
updateCachedData(epochModel, cachedData, weightVector);
// Formulate a min-max equation system max(A*x+b)=x for the weighted sum of the objectives
assert(cachedData.bMinMax.capacity() >= epochModel.epochMatrix.getRowCount());
assert(cachedData.xMinMax.size() == epochModel.epochMatrix.getRowGroupCount());
cachedData.bMinMax.assign(epochModel.epochMatrix.getRowCount(), storm::utility::zero<ValueType>());
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
ValueType weight = storm::solver::minimize(this->objectives[objIndex].formula->getOptimalityType()) ? -weightVector[objIndex] : weightVector[objIndex];
if (!storm::utility::isZero(weight)) {
std::vector<ValueType> const& objectiveReward = epochModel.objectiveRewards[objIndex];
for (auto const& choice : epochModel.objectiveRewardFilter[objIndex]) {
cachedData.bMinMax[choice] += weight * objectiveReward[choice];
}
}
}
if (obj.upperResultBound) {
cachedData.linEqSolver->setUpperBound(*obj.upperResultBound);
req.clearUpperBounds();
auto stepSolutionIt = epochModel.stepSolutions.begin();
for (auto const& choice : epochModel.stepChoices) {
cachedData.bMinMax[choice] += stepSolutionIt->front();
++stepSolutionIt;
}
STORM_LOG_THROW(req.empty(), storm::exceptions::UncheckedRequirementException, "At least one requirement of the LinearEquationSolver was not met.");
swEqBuilding.stop();
swLinEqSolving.start();
cachedData.linEqSolver->solveEquations(x, cachedData.bLinEq);
swLinEqSolving.stop();
swEqBuilding.start();
auto resultIt = result.begin();
// Invoke the min max solver
cachedData.minMaxSolver->solveEquations(cachedData.xMinMax, cachedData.bMinMax);
for (auto const& state : epochModel.epochInStates) {
resultIt->push_back(x[state]);
++resultIt;
result.emplace_back();
result.back().reserve(solutionSize);
result.back().push_back(cachedData.xMinMax[state]);
}
// Check whether the linear equation solver needs to be updated
auto const& choices = cachedData.minMaxSolver->getSchedulerChoices();
if (cachedData.schedulerChoices != choices) {
std::vector<uint64_t> choicesTmp = choices;
cachedData.minMaxSolver->setInitialScheduler(std::move(choicesTmp));
++numSchedChanges;
cachedData.schedulerChoices = choices;
storm::solver::GeneralLinearEquationSolverFactory<ValueType> linEqSolverFactory;
bool needEquationSystem = linEqSolverFactory.getEquationProblemFormat() == storm::solver::LinearEquationSolverProblemFormat::EquationSystem;
storm::storage::SparseMatrix<ValueType> subMatrix = epochModel.epochMatrix.selectRowsFromRowGroups(choices, needEquationSystem);
if (needEquationSystem) {
subMatrix.convertToEquationSystem();
}
cachedData.linEqSolver = linEqSolverFactory.create(std::move(subMatrix));
cachedData.linEqSolver->setCachingEnabled(true);
}
// Formulate for each objective the linear equation system induced by the performed choices
assert(cachedData.bLinEq.size() == choices.size());
for (uint64_t objIndex = 0; objIndex < this->objectives.size(); ++objIndex) {
auto const& obj = this->objectives[objIndex];
std::vector<ValueType> const& objectiveReward = epochModel.objectiveRewards[objIndex];
auto rowGroupIndexIt = epochModel.epochMatrix.getRowGroupIndices().begin();
auto choiceIt = choices.begin();
auto stepChoiceIt = epochModel.stepChoices.begin();
auto stepSolutionIt = epochModel.stepSolutions.begin();
std::vector<ValueType>& x = cachedData.xLinEq[objIndex];
auto xIt = x.begin();
for (auto& b_i : cachedData.bLinEq) {
uint64_t i = *rowGroupIndexIt + *choiceIt;
if (epochModel.objectiveRewardFilter[objIndex].get(i)) {
b_i = objectiveReward[i];
} else {
b_i = storm::utility::zero<ValueType>();
}
while (*stepChoiceIt < i) {
++stepChoiceIt;
++stepSolutionIt;
}
if (i == *stepChoiceIt) {
b_i += (*stepSolutionIt)[objIndex + 1];
++stepChoiceIt;
++stepSolutionIt;
}
// We can already set x_i correctly if row i is empty.
// Appearingly, some linear equation solvers struggle to converge otherwise.
if (epochModel.epochMatrix.getRow(i).getNumberOfEntries() == 0) {
*xIt = b_i;
}
++xIt;
++rowGroupIndexIt;
++choiceIt;
}
assert(x.size() == choices.size());
auto req = cachedData.linEqSolver->getRequirements();
cachedData.linEqSolver->clearBounds();
if (obj.lowerResultBound) {
req.clearLowerBounds();
cachedData.linEqSolver->setLowerBound(*obj.lowerResultBound);
}
if (obj.upperResultBound) {
cachedData.linEqSolver->setUpperBound(*obj.upperResultBound);
req.clearUpperBounds();
}
STORM_LOG_THROW(req.empty(), storm::exceptions::UncheckedRequirementException, "At least one requirement of the LinearEquationSolver was not met.");
cachedData.linEqSolver->solveEquations(x, cachedData.bLinEq);
auto resultIt = result.begin();
for (auto const& state : epochModel.epochInStates) {
resultIt->push_back(x[state]);
++resultIt;
}
}
}
swEqBuilding.stop();
swAux3.stop();
rewardUnfolding.setSolutionForCurrentEpoch(std::move(result));
swEpochModelAnalysis.stop();
}
template <class SparseMdpModelType>
void SparseMdpRewardBoundedPcaaWeightVectorChecker<SparseMdpModelType>::updateCachedData(typename MultiDimensionalRewardUnfolding<ValueType, false>::EpochModel const& epochModel, EpochCheckingData& cachedData, std::vector<ValueType> const& weightVector) {
if (epochModel.epochMatrixChanged) {
swDataUpdate.start();
// Update the cached MinMaxSolver data
cachedData.bMinMax.resize(epochModel.epochMatrix.getRowCount());
@ -249,7 +313,6 @@ namespace storm {
for (auto& x_o : cachedData.xLinEq) {
x_o.assign(epochModel.epochMatrix.getRowGroupCount(), storm::utility::zero<ValueType>());
}
swDataUpdate.stop();
}
}

18
src/storm/modelchecker/multiobjective/pcaa/SparseMdpRewardBoundedPcaaWeightVectorChecker.h
View File

@ -30,17 +30,13 @@ namespace storm {
virtual ~SparseMdpRewardBoundedPcaaWeightVectorChecker() {
swAll.stop();
std::cout << "WVC statistics: " << std::endl;
std::cout << " overall: " << swAll << " seconds." << std::endl;
std::cout << " overall Time: " << swAll << " seconds." << std::endl;
std::cout << "---------------------------------------------" << std::endl;
std::cout << " Sched changed " << numSchedChanges << "/" << numCheckedEpochs << " times." << std::endl;
std::cout << " dataUpdate: " << swDataUpdate << " seconds." << std::endl;
std::cout << " eqSysBuilding: " << swEqBuilding << " seconds." << std::endl;
std::cout << " MinMaxSolving: " << swMinMaxSolving << " seconds." << std::endl;
std::cout << " LinEqSolving: " << swLinEqSolving << " seconds." << std::endl;
std::cout << " Aux1StopWatch: " << swAux1 << " seconds." << std::endl;
std::cout << " Aux2StopWatch: " << swAux2 << " seconds." << std::endl;
std::cout << " Aux3StopWatch: " << swAux3 << " seconds." << std::endl;
std::cout << " #checked weight vectors:" << numChecks << "." << std::endl;
std::cout << " #checked epochs:" << numCheckedEpochs << "." << std::endl;
std::cout << "#Sched reused from prev. ep.: " << (numCheckedEpochs - numSchedChanges) << "." << std::endl;
std::cout << " Epoch Model building time: " << swEpochModelBuild << " seconds." << std::endl;
std::cout << " Epoch Model checking time: " << swEpochModelAnalysis << " seconds." << std::endl;
}
@ -81,7 +77,7 @@ namespace storm {
void updateCachedData(typename MultiDimensionalRewardUnfolding<ValueType, false>::EpochModel const& epochModel, EpochCheckingData& cachedData, std::vector<ValueType> const& weightVector);
storm::utility::Stopwatch swAll, swDataUpdate, swEqBuilding, swLinEqSolving, swMinMaxSolving, swAux1, swAux2, swAux3;
storm::utility::Stopwatch swAll, swEpochModelBuild, swEpochModelAnalysis;
uint64_t numSchedChanges, numCheckedEpochs, numChecks;
MultiDimensionalRewardUnfolding<ValueType, false> rewardUnfolding;

16
src/storm/modelchecker/multiobjective/rewardbounded/MultiDimensionalRewardUnfolding.cpp
View File

@ -58,12 +58,10 @@ namespace storm {
maxSolutionsStored = 0;
swInit.start();
STORM_LOG_ASSERT(!SingleObjectiveMode || (this->objectives.size() == 1), "Enabled single objective mode but there are multiple objectives.");
std::vector<Epoch> epochSteps;
initializeObjectives(epochSteps);
initializeMemoryProduct(epochSteps);
swInit.stop();
}
template<typename ValueType, bool SingleObjectiveMode>
@ -291,7 +289,6 @@ namespace storm {
epochModel.epochMatrixChanged = false;
}
swSetEpoch.start();
bool containsLowerBoundedObjective = false;
for (auto const& dimension : dimensions) {
if (!dimension.isUpperBounded) {
@ -364,7 +361,6 @@ namespace storm {
assert(epochModel.stepChoices.getNumberOfSetBits() == epochModel.stepSolutions.size());
currentEpoch = epoch;
swSetEpoch.stop();
/*
std::cout << "Epoch model for epoch " << storm::utility::vector::toString(epoch) << std::endl;
std::cout << "Matrix: " << std::endl << epochModel.epochMatrix << std::endl;
@ -384,7 +380,6 @@ namespace storm {
void MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::setCurrentEpochClass(Epoch const& epoch) {
EpochClass epochClass = epochManager.getEpochClass(epoch);
// std::cout << "Setting epoch class for epoch " << epochManager.toString(epoch) << std::endl;
swSetEpochClass.start();
auto productObjectiveRewards = productModel->computeObjectiveRewards(epochClass, objectives);
storm::storage::BitVector stepChoices(productModel->getProduct().getNumberOfChoices(), false);
@ -455,34 +450,25 @@ namespace storm {
epochModel.objectiveRewards.push_back(std::move(reducedModelObjRewards));
}
swAux4.start();
swAux1.start();
epochModel.epochInStates = storm::storage::BitVector(epochModel.epochMatrix.getRowGroupCount(), false);
for (auto const& productState : productInStates) {
STORM_LOG_ASSERT(ecElimResult.oldToNewStateMapping[productState] < epochModel.epochMatrix.getRowGroupCount(), "Selected product state does not exist in the epoch model.");
epochModel.epochInStates.set(ecElimResult.oldToNewStateMapping[productState], true);
}
swAux1.stop();
swAux2.start();
std::vector<uint64_t> toEpochModelInStatesMap(productModel->getProduct().getNumberOfStates(), std::numeric_limits<uint64_t>::max());
std::vector<uint64_t> epochModelStateToInStateMap = epochModel.epochInStates.getNumberOfSetBitsBeforeIndices();
for (auto const& productState : productInStates) {
toEpochModelInStatesMap[productState] = epochModelStateToInStateMap[ecElimResult.oldToNewStateMapping[productState]];
}
productStateToEpochModelInStateMap = std::make_shared<std::vector<uint64_t> const>(std::move(toEpochModelInStatesMap));
swAux2.stop();
swAux3.start();
epochModel.objectiveRewardFilter.clear();
for (auto const& objRewards : epochModel.objectiveRewards) {
epochModel.objectiveRewardFilter.push_back(storm::utility::vector::filterZero(objRewards));
epochModel.objectiveRewardFilter.back().complement();
}
swAux3.stop();
swAux4.stop();
swSetEpochClass.stop();
epochModelSizes.push_back(epochModel.epochMatrix.getRowGroupCount());
}
@ -544,7 +530,6 @@ namespace storm {
template<typename ValueType, bool SingleObjectiveMode>
void MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::setSolutionForCurrentEpoch(std::vector<SolutionType>&& inStateSolutions) {
swInsertSol.start();
STORM_LOG_ASSERT(currentEpoch, "Tried to set a solution for the current epoch, but no epoch was specified before.");
STORM_LOG_ASSERT(inStateSolutions.size() == epochModel.epochInStates.getNumberOfSetBits(), "Invalid number of solutions.");
@ -575,7 +560,6 @@ namespace storm {
epochSolutions[currentEpoch.get()] = std::move(solution);
maxSolutionsStored = std::max((uint64_t) epochSolutions.size(), maxSolutionsStored);
swInsertSol.stop();
}

18
src/storm/modelchecker/multiobjective/rewardbounded/MultiDimensionalRewardUnfolding.h
View File

@ -47,20 +47,10 @@ namespace storm {
MultiDimensionalRewardUnfolding(storm::models::sparse::Mdp<ValueType> const& model, std::shared_ptr<storm::logic::OperatorFormula const> objectiveFormula);
~MultiDimensionalRewardUnfolding() {
std::cout << "Unfolding statistics: " << std::endl;
std::cout << " init: " << swInit << " seconds." << std::endl;
std::cout << " setEpoch: " << swSetEpoch << " seconds." << std::endl;
std::cout << " setEpochClass: " << swSetEpochClass << " seconds." << std::endl;
std::cout << " findSolutions: " << swFindSol << " seconds." << std::endl;
std::cout << " insertSolutions: " << swInsertSol << " seconds." << std::endl;
std::cout << " aux1StopWatch: " << swAux1 << " seconds." << std::endl;
std::cout << " aux2StopWatch: " << swAux2 << " seconds." << std::endl;
std::cout << " aux3StopWatch: " << swAux3 << " seconds." << std::endl;
std::cout << " aux4StopWatch: " << swAux4 << " seconds." << std::endl;
std::cout << "---------------------------------------------" << std::endl;
std::cout << " Product size: " << productModel->getProduct().getNumberOfStates() << std::endl;
std::cout << "maxSolutionsStored: " << maxSolutionsStored << std::endl;
std::cout << " Epoch model sizes: ";
std::cout << "Implicit unfolding statistics: " << std::endl;
std::cout << " Memory Product size: " << productModel->getProduct().getNumberOfStates() << std::endl;
std::cout << " maxSolutionsStored: " << maxSolutionsStored << std::endl;
std::cout << "Occurring Epoch model sizes: ";
for (auto const& i : epochModelSizes) {
std::cout << i << " ";
}

Write Preview
Loading…
Cancel
Save