Page MenuHomePhorge
Files F386359

Reliability.h
No OneTemporary
Actions

Size
8 KB
Referenced Files
None
Subscribers
None

Reliability.h
View Options

//===-- rosa/agent/Reliability.h --------------------------------*- C++ -*-===//
//
// The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \file rosa/agent/Reliability.h
///
/// \author Daniel Schnoell (danielschnoell@tuwien.ac.at)
///
/// \date 2019
///
/// \brief Declaration of `rosa::Reliability` base-class.
///
//===----------------------------------------------------------------------===//
#ifndef ROSA_AGENT_RELIABILITY_H
#define ROSA_AGENT_RELIABILITY_H
#include "rosa/agent/FunctionAbstractions.hpp"
#include "rosa/agent/Functionality.h"
#include "rosa/agent/RangeConfidence.hpp"
#include "rosa/agent/CrossReliability.h"
#include <vector>
namespace rosa {
namespace agent {
template <typename SensorValueType, typename StateType, typename ReliabilityType>
class LowLevel {
struct ConfOrRel {
StateType score;
ReliabilityType Reliability;
};
std::vector<std::vector<ConfOrRel>> History;
std::size_t HistoryMaxSize;
std::vector<ConfOrRel> ValuesFromMaster;
SensorValueType previousSensorValue;
unsigned int valueSetCounter;
std::vector<StateType> States;
bool PreviousSensorValueExists = false;
RangeConfidence<ReliabilityType, StateType, SensorValueType>* Confidence;
Abstraction<SensorValueType, ReliabilityType>* Reliability;
Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope;
Abstraction<std::size_t, ReliabilityType>* TimeConfidence;
ReliabilityType getRelibility(SensorValueType actualValue, SensorValueType lastValue, unsigned int valueSetCounter) {
ReliabilityType relAbs = Reliability->operator()(actualValue);
ReliabilityType relSlo = ReliabilitySlope->operator()((lastValue - actualValue) / (SensorValueType)valueSetCounter);
// calculate signal input reliability
// NOTE: options would be multiply, average, AND (best to worst:
// average = AND > multiply) rel = relAbs * relSlo; rel = (relAbs +
// relSlo)/2;
return std::min(relAbs, relSlo);
}
std::vector<ConfOrRel> getAllPossibleScoresBasedOnHistory(std::vector<ConfOrRel> possibleScores) {
//iterate through all history entries
std::size_t posInHistory = 0;
typedef typename std::vector<std::vector<ConfOrRel>>::iterator iter;
for (iter pShE = History.begin(); pShE < History.end(); pShE++, posInHistory++) {
//iterate through all possible scores of each history entry
for (typename std::vector<ConfOrRel>::iterator pSh : *pShE) {
//printf("a3\n");
int historyScore = pSh->score;
float historyConf = pSh->Reliability;
//combine each history score with the confidence of time
//NOTE: multiplication, AND, or average would be alternatives (best to worst: multiplication = AND = average)
historyConf = historyConf * TimeConfidence(posInHistory);
//historyConf = (historyConf + TimeConfidence(posInHistory)) / 2;
//historyConf = std::min(historyConf, TimeConfidence(posInHistory));
//printf("a4\n");
bool foundScore = false;
for (ConfOrRel& pS : possibleScores) {
if (pS->score == historyScore) {
//calculate confidence for score
//NOTE: multiplication, AND, or average would be alternatives (best to worst: AND >> average = multiplication )
//pS->confOrRel = pS->confOrRel * historyConf;
//pS->confOrRel = (pS->confOrRel + historyConf) / 2;
pS->confOrRel = std::max(pS->confOrRel, historyConf);
foundScore = true;
}
}
if (foundScore == false) {
ConfOrRel possibleScore;
possibleScore.score = historyScore;
possibleScore.Reliability = historyConf;
possibleScores->push_back(possibleScore);
}
}
}
return possibleScores;
}
void saveInHistory(std::vector<ConfOrRel> actualPossibleScores) {
//check if the reliability of at least one possible score is high enough
bool atLeastOneRelIsHigh = false;
for (ConfOrRel pS : actualPossibleScores) {
if (pS.Reliability > 0.5) {
atLeastOneRelIsHigh = true;
}
}
//save possible scores if at least one possible score is high enough (or if the history is empty)
if (History.size() < 1 || atLeastOneRelIsHigh == true) {
History.push_front(actualPossibleScores);
//if history size is higher than allowed, savo oldest element
while (History.size() > HistoryMaxSize) {
//delete possibleScoreHistory.back();
History.pop_back();
}
}
}
ConfOrRel operator()(SensorValueType SensorValue) {
std::map<StateType, ReliabilityType> ActuallPosibleScores_tmp = Confidence(SensorValue);
std::vector<ConfOrRel> ActuallPossibleScores;
for (auto state : States)
ActuallPossibleScores.push_back({ state, ActuallPosibleScores_tmp.find(state) });
ReliabilityType inputReliability;
if (PreviousSensorValueExists)
inputReliability = getRelibility(SensorValue, previousSensorValue, valueSetCounter);
else
inputReliability = Reliability(SensorValue);
for (std::size_t at = 0; at < ActuallPossibleScores.size(); at++)
ActuallPossibleScores.at(at) = std::min(ActuallPossibleScores.at(at), inputReliability);
for (std::size_t APS_at = 0; APS_at < ActuallPossibleScores.size(); APS_at++)
for (std::size_t VFM_at = 0; VFM_at < ValuesFromMaster.size(); VFM_at++) {
if (ActuallPossibleScores.at(APS_at).score == ValuesFromMaster.at(VFM_at).score) {
ActuallPossibleScores.at(APS_at).Reliability = ActuallPossibleScores.at(APS_at).Reliability + ValuesFromMaster.at(VFM_at).Reliability;
}
}
saveInHistory(ActuallPossibleScores);
std::vector<ConfOrRel> possibleScores;
getAllPossibleScoresBasedOnHistory(&possibleScores);
std::sort(possibleScores.begin(), possibleScores.end(), [](ReliabilityType A, ReliabilityType B)-> bool {return A > B; });
previousSensorValue = SensorValue;
PreviousSensorValueExists = true;
return possibleScores.at(0);
}
};
template<typename StateType, typename ReliabilityType>
class HighLevel
{
struct ConfOrRel {
StateType score;
ReliabilityType Reliability;
};
struct returnType {
ReliabilityType CrossReliability;
std::vector<std::pair<id_t, std::vector<ConfOrRel>>> CrossConfidence;
};
CrossReliability<StateType, ReliabilityType>* CrossReliability = nullptr;
CrossConfidence <StateType, ReliabilityType>* CrossConfidence = nullptr;
returnType operator()(std::vector<std::tuple<id_t, StateType, ReliabilityType>> Values)
{
StateType EWS = 0;
ReliabilityType combinedInputRel = 1;
ReliabilityType combinedCrossRel = 1;
ReliabilityType outputReliability;
std::vector<std::pair<id_t, StateType>> Agents;
std::vector<std::pair<id_t, std::vector<ConfOrRel>>> output;
std::vector<ConfOrRel> output_temporary;
for (auto tmp : Values)
{
std::pair<id_t, StateType> tmp2;
tmp.first = std::get<0>(tmp);
tmp.second = std::get<1>(tmp);
Agents.push_back(tmp);
}
for (auto Value : Values) {
StateType sc = std::get<1>(Value);
ReliabilityType rel = std::get<2>(Value);
EWS = EWS + sc;
combinedInputRel = std::min(combinedInputRel, rel);
//calculate the cross reliability for this slave agent
ReliabilityType realCrossReliabilityOfSlaveAgent = CrossReliability({ std::get<0>(Value),std::get<1>(Value) }, Agents); //AVERAGE, MULTIPLICATION, CONJUNCTION (best to worst: AVERAGE = CONJUNCTION > MULTIPLICATION >> )
output_temporary.clear();
for (int theoreticalScore = 0; theoreticalScore <= 3; theoreticalScore++) {
//calculate the cross reliability for this slave agent
ConfOrRel data;
data.score = theoreticalScore;
data.Reliability = CrossConfidence(std::get<0>(Value), theoreticalScore, Agents);
output_temporary.push_back(data);
}
output.push_back({ std::get<0>(Value),output_temporary });
combinedCrossRel = std::min(combinedCrossRel, realCrossReliabilityOfSlaveAgent);
}
//combine cross reliabilites and input reliabilites of all slave agents
//NOTE: options would be multiply, average, AND (best to worst: )
//outputReliability = combinedInputRel * combinedCrossRel;
//outputReliability = (combinedInputRel + combinedCrossRel) / 2;
outputReliability = std::min(combinedInputRel, combinedCrossRel);
return { outputReliability,output };
}
};
} // namespace agent
}// namespace rosa
#endif // !ROSA_AGENT_RELIABILITY_H

File Metadata

Mime Type
text/x-c++
Expires
Thu, Jul 3, 7:16 AM (1 d, 9 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
157202
Default Alt Text
Reliability.h (8 KB)

Event Timeline