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. 105
      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

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

@ -85,17 +85,94 @@ 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;
// 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();
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;
}
// 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>());
}
}
}
}
} else {
updateCachedData(epochModel, cachedData, weightVector);
// 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>());
@ -113,14 +190,9 @@ namespace storm {
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);
@ -132,7 +204,6 @@ namespace storm {
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;
@ -143,11 +214,9 @@ namespace storm {
}
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];
@ -195,26 +264,21 @@ namespace storm {
req.clearUpperBounds();
}
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();
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