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

Quantiles: Improved performance by excluding already analyzed epochs from the created epochSequences

main
Tim Quatmann 6 years ago
parent
971f4c8508
commit
aa3a1f5ff7
4 changed files with 44 additions and 65 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 29
      src/storm/modelchecker/prctl/helper/rewardbounded/MultiDimensionalRewardUnfolding.cpp
  2. 11
      src/storm/modelchecker/prctl/helper/rewardbounded/MultiDimensionalRewardUnfolding.h
  3. 14
      src/storm/modelchecker/prctl/helper/rewardbounded/QuantileHelper.cpp
  4. 1
      src/storm/modelchecker/prctl/helper/rewardbounded/QuantileHelper.h

29
src/storm/modelchecker/prctl/helper/rewardbounded/MultiDimensionalRewardUnfolding.cpp
View File

@ -64,8 +64,6 @@ namespace storm {
template<typename ValueType, bool SingleObjectiveMode> template<typename ValueType, bool SingleObjectiveMode>
void MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::initialize(std::set<storm::expressions::Variable> const& infinityBoundVariables) { void MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::initialize(std::set<storm::expressions::Variable> const& infinityBoundVariables) {
maxSolutionsStored = 0;
STORM_LOG_ASSERT(!SingleObjectiveMode || (this->objectives.size() == 1), "Enabled single objective mode but there are multiple objectives."); STORM_LOG_ASSERT(!SingleObjectiveMode || (this->objectives.size() == 1), "Enabled single objective mode but there are multiple objectives.");
std::vector<Epoch> epochSteps; std::vector<Epoch> epochSteps;
initializeObjectives(epochSteps, infinityBoundVariables); initializeObjectives(epochSteps, infinityBoundVariables);
@ -333,41 +331,27 @@ namespace storm {
} }
template<typename ValueType, bool SingleObjectiveMode> template<typename ValueType, bool SingleObjectiveMode>
std::vector<typename MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::Epoch> MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::getEpochComputationOrder(Epoch const& startEpoch) {
std::vector<typename MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::Epoch> MultiDimensionalRewardUnfolding<ValueType, SingleObjectiveMode>::getEpochComputationOrder(Epoch const& startEpoch, bool stopAtComputedEpochs) {
// Perform a DFS to find all the reachable epochs // Perform a DFS to find all the reachable epochs
std::vector<Epoch> dfsStack; std::vector<Epoch> dfsStack;
std::set<Epoch, std::function<bool(Epoch const&, Epoch const&)>> collectedEpochs(std::bind(&EpochManager::epochClassZigZagOrder, &epochManager, std::placeholders::_1, std::placeholders::_2)); std::set<Epoch, std::function<bool(Epoch const&, Epoch const&)>> collectedEpochs(std::bind(&EpochManager::epochClassZigZagOrder, &epochManager, std::placeholders::_1, std::placeholders::_2));
if (!stopAtComputedEpochs || epochSolutions.count(startEpoch) == 0) {
collectedEpochs.insert(startEpoch); collectedEpochs.insert(startEpoch);
dfsStack.push_back(startEpoch); dfsStack.push_back(startEpoch);
}
while (!dfsStack.empty()) { while (!dfsStack.empty()) {
Epoch currentEpoch = dfsStack.back(); Epoch currentEpoch = dfsStack.back();
dfsStack.pop_back(); dfsStack.pop_back();
for (auto const& step : possibleEpochSteps) { for (auto const& step : possibleEpochSteps) {
Epoch successorEpoch = epochManager.getSuccessorEpoch(currentEpoch, step); Epoch successorEpoch = epochManager.getSuccessorEpoch(currentEpoch, step);
/*
for (auto const& e : collectedEpochs) {
std::cout << "Comparing " << epochManager.toString(e) << " and " << epochManager.toString(successorEpoch) << std::endl;
if (epochManager.epochClassZigZagOrder(e, successorEpoch)) {
std::cout << " " << epochManager.toString(e) << " < " << epochManager.toString(successorEpoch) << std::endl;
}
if (epochManager.epochClassZigZagOrder(successorEpoch, e)) {
std::cout << " " << epochManager.toString(e) << " > " << epochManager.toString(successorEpoch) << std::endl;
}
}
*/
if (!stopAtComputedEpochs || epochSolutions.count(successorEpoch) == 0) {
if (collectedEpochs.insert(successorEpoch).second) { if (collectedEpochs.insert(successorEpoch).second) {
dfsStack.push_back(std::move(successorEpoch)); dfsStack.push_back(std::move(successorEpoch));
} }
} }
} }
/*
std::cout << "Resulting order: ";
for (auto const& e : collectedEpochs) {
std::cout << epochManager.toString(e) << ", ";
} }
std::cout << std::endl;
*/
return std::vector<Epoch>(collectedEpochs.begin(), collectedEpochs.end()); return std::vector<Epoch>(collectedEpochs.begin(), collectedEpochs.end());
} }
@ -629,8 +613,6 @@ namespace storm {
epochModel.objectiveRewardFilter.push_back(storm::utility::vector::filterZero(objRewards)); epochModel.objectiveRewardFilter.push_back(storm::utility::vector::filterZero(objRewards));
epochModel.objectiveRewardFilter.back().complement(); epochModel.objectiveRewardFilter.back().complement();
} }
epochModelSizes.push_back(epochModel.epochMatrix.getRowGroupCount());
} }
@ -846,9 +828,6 @@ namespace storm {
solution.productStateToSolutionVectorMap = productStateToEpochModelInStateMap; solution.productStateToSolutionVectorMap = productStateToEpochModelInStateMap;
solution.solutions = std::move(inStateSolutions); solution.solutions = std::move(inStateSolutions);
epochSolutions[currentEpoch.get()] = std::move(solution); epochSolutions[currentEpoch.get()] = std::move(solution);
maxSolutionsStored = std::max((uint64_t) epochSolutions.size(), maxSolutionsStored);
} }
template<typename ValueType, bool SingleObjectiveMode> template<typename ValueType, bool SingleObjectiveMode>

11
src/storm/modelchecker/prctl/helper/rewardbounded/MultiDimensionalRewardUnfolding.h
View File

@ -54,7 +54,11 @@ namespace storm {
*/ */
Epoch getStartEpoch(bool setUnknownDimsToBottom = false); Epoch getStartEpoch(bool setUnknownDimsToBottom = false);
std::vector<Epoch> getEpochComputationOrder(Epoch const& startEpoch);
/*!
* Computes a sequence of epochs that need to be analyzed to get a result at the start epoch.
* @param stopAtComputedEpochs if set, the search for epochs that need to be computed is stopped at epochs that already have been computed earlier.
*/
std::vector<Epoch> getEpochComputationOrder(Epoch const& startEpoch, bool stopAtComputedEpochs = false);
EpochModel<ValueType, SingleObjectiveMode>& setCurrentEpoch(Epoch const& epoch); EpochModel<ValueType, SingleObjectiveMode>& setCurrentEpoch(Epoch const& epoch);
@ -138,11 +142,6 @@ namespace storm {
std::vector<Dimension<ValueType>> dimensions; std::vector<Dimension<ValueType>> dimensions;
std::vector<storm::storage::BitVector> objectiveDimensions; std::vector<storm::storage::BitVector> objectiveDimensions;
storm::utility::Stopwatch swInit, swFindSol, swInsertSol, swSetEpoch, swSetEpochClass, swAux1, swAux2, swAux3, swAux4;
std::vector<uint64_t> epochModelSizes;
uint64_t maxSolutionsStored;
}; };
} }
} }

14
src/storm/modelchecker/prctl/helper/rewardbounded/QuantileHelper.cpp
View File

@ -186,6 +186,7 @@ namespace storm {
numCheckedEpochs = 0; numCheckedEpochs = 0;
numPrecisionRefinements = 0; numPrecisionRefinements = 0;
swEpochAnalysis.reset(); swEpochAnalysis.reset();
swExploration.reset();
cachedSubQueryResults.clear(); cachedSubQueryResults.clear();
std::vector<std::vector<ValueType>> result; std::vector<std::vector<ValueType>> result;
@ -217,7 +218,8 @@ namespace storm {
if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) { if (storm::settings::getModule<storm::settings::modules::CoreSettings>().isShowStatisticsSet()) {
std::cout << "Number of checked epochs: " << numCheckedEpochs << std::endl; std::cout << "Number of checked epochs: " << numCheckedEpochs << std::endl;
std::cout << "Number of required precision refinements: " << numPrecisionRefinements << std::endl; std::cout << "Number of required precision refinements: " << numPrecisionRefinements << std::endl;
std::cout << "Time for epoch model analysis: " << swEpochAnalysis << " seconds." << std::endl;
std::cout << "Time for epoch exploration: " << swExploration << " seconds." << std::endl;
std::cout << "\tTime for epoch model analysis: " << swEpochAnalysis << " seconds." << std::endl;
} }
return result; return result;
} }
@ -359,8 +361,7 @@ namespace storm {
auto upperBound = rewardUnfolding.getUpperObjectiveBound(); auto upperBound = rewardUnfolding.getUpperObjectiveBound();
std::vector<ValueType> x, b; std::vector<ValueType> x, b;
std::unique_ptr<storm::solver::MinMaxLinearEquationSolver<ValueType>> minMaxSolver; std::unique_ptr<storm::solver::MinMaxLinearEquationSolver<ValueType>> minMaxSolver;
std::set<EpochManager::Epoch> checkedEpochs;
swExploration.start();
bool progress = true; bool progress = true;
for (CostLimit candidateCostLimitSum(0); progress; ++candidateCostLimitSum.get()) { for (CostLimit candidateCostLimitSum(0); progress; ++candidateCostLimitSum.get()) {
CostLimits currentCandidate(satCostLimits.dimension(), CostLimit(0)); CostLimits currentCandidate(satCostLimits.dimension(), CostLimit(0));
@ -389,12 +390,10 @@ namespace storm {
++costLimitIt; ++costLimitIt;
} }
STORM_LOG_DEBUG("Checking start epoch " << rewardUnfolding.getEpochManager().toString(startEpoch) << "."); STORM_LOG_DEBUG("Checking start epoch " << rewardUnfolding.getEpochManager().toString(startEpoch) << ".");
auto epochSequence = rewardUnfolding.getEpochComputationOrder(startEpoch);
auto epochSequence = rewardUnfolding.getEpochComputationOrder(startEpoch, true);
for (auto const& epoch : epochSequence) { for (auto const& epoch : epochSequence) {
if (checkedEpochs.count(epoch) == 0) {
++numCheckedEpochs; ++numCheckedEpochs;
swEpochAnalysis.start(); swEpochAnalysis.start();
checkedEpochs.insert(epoch);
auto& epochModel = rewardUnfolding.setCurrentEpoch(epoch); auto& epochModel = rewardUnfolding.setCurrentEpoch(epoch);
rewardUnfolding.setSolutionForCurrentEpoch(epochModel.analyzeSingleObjective(env,boundedUntilOperator.getOptimalityType(), x, b, minMaxSolver, lowerBound, upperBound)); rewardUnfolding.setSolutionForCurrentEpoch(epochModel.analyzeSingleObjective(env,boundedUntilOperator.getOptimalityType(), x, b, minMaxSolver, lowerBound, upperBound));
swEpochAnalysis.stop(); swEpochAnalysis.stop();
@ -409,6 +408,7 @@ namespace storm {
propertySatisfied = boundedUntilOperator.getBound().isSatisfied(lowerUpperValue.first); propertySatisfied = boundedUntilOperator.getBound().isSatisfied(lowerUpperValue.first);
if (propertySatisfied != boundedUntilOperator.getBound().isSatisfied(lowerUpperValue.second)) { if (propertySatisfied != boundedUntilOperator.getBound().isSatisfied(lowerUpperValue.second)) {
// unclear result due to insufficient precision. // unclear result due to insufficient precision.
swExploration.stop();
return false; return false;
} }
} else { } else {
@ -422,9 +422,9 @@ namespace storm {
} }
} }
} }
}
} while (getNextCandidateCostLimit(candidateCostLimitSum, currentCandidate)); } while (getNextCandidateCostLimit(candidateCostLimitSum, currentCandidate));
} }
swExploration.stop();
return true; return true;
} }

1
src/storm/modelchecker/prctl/helper/rewardbounded/QuantileHelper.h
View File

@ -53,6 +53,7 @@ namespace storm {
mutable uint64_t numCheckedEpochs; mutable uint64_t numCheckedEpochs;
mutable uint64_t numPrecisionRefinements; mutable uint64_t numPrecisionRefinements;
mutable storm::utility::Stopwatch swEpochAnalysis; mutable storm::utility::Stopwatch swEpochAnalysis;
mutable storm::utility::Stopwatch swExploration;
}; };
} }
} }

Write Preview
Loading…
Cancel
Save