diff --git a/include/rosa/agent/Reliability.h b/include/rosa/agent/Reliability.h index 28ead80..2f33665 100644 --- a/include/rosa/agent/Reliability.h +++ b/include/rosa/agent/Reliability.h @@ -1,106 +1,242 @@ //===-- 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 namespace rosa { namespace agent { template - class try_2 { + class LowLevel { struct ConfOrRel { StateType score; ReliabilityType Reliability; }; std::vector> History; std::size_t HistoryMaxSize; std::vector ValuesFromMaster; SensorValueType previousSensorValue; unsigned int valueSetCounter; std::vector States; + bool PreviousSensorValueExists = false; RangeConfidence* Confidence; Abstraction* Reliability; Abstraction* ReliabilitySlope; + Abstraction* TimeConfidence; ReliabilityType getRelibility(SensorValueType actualValue, SensorValueType lastValue, unsigned int valueSetCounter) { - ReliabilityType relAbs, relSlo; - - SensorValueType = Reliability(actualValue); - SensorValueType = ReliabilitySlope((lastValue - actualValue) / (SensorValueType)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; - rel = std::min(relAbs, relSlo); - return rel; + return std::min(relAbs, relSlo); + } + + std::vector getAllPossibleScoresBasedOnHistory(std::vector possibleScores) { + //iterate through all history entries + std::size_t posInHistory = 0; + typedef typename std::vector>::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::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 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 ActuallPosibleScores_tmp = Confidence(SensorValue); std::vector ActuallPossibleScores; for (auto state : States) ActuallPossibleScores.push_back({ state, ActuallPosibleScores_tmp.find(state) }); ReliabilityType inputReliability; - if (mountedAgent->getPreviousSensorValue(&previousSensorValue)) - inputReliability = Reliability(actualSensorValue, previousSensorValue, valueSetCounter); + if (PreviousSensorValueExists) + inputReliability = getRelibility(SensorValue, previousSensorValue, valueSetCounter); else inputReliability = Reliability(SensorValue); - for (std::size_t at = 0, at < ActuallPossibleScores.size(); at++) + 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; } } - saveActualPossibleScoresInHistory(ActuallPossibleScores); + saveInHistory(ActuallPossibleScores); std::vector possibleScores; getAllPossibleScoresBasedOnHistory(&possibleScores); - std::sort(possibleScores.begin(), possibleScores.end(), compareByConfRel); + std::sort(possibleScores.begin(), possibleScores.end(), [](ReliabilityType A, ReliabilityType B)-> bool {return A > B; }); previousSensorValue = SensorValue; + PreviousSensorValueExists = true; return possibleScores.at(0); + + } + }; + + + template + class HighLevel + { + struct ConfOrRel { + StateType score; + ReliabilityType Reliability; }; - } // namespace agent - } // namespace rosa + CrossReliability + + + std::vector operator(std::vector Values) + { + + int EWS = 0; + float combinedInputRel = 1; + float combinedCrossRel = 1; + float outputReliability; + + unsigned int numOfSlaveAgentsWereChecked = 0; + + for (auto Value:Values) { + StateType sc=Value.score; + ReliabilityType rel=Value.Reliability; + + EWS = EWS + sc; + + combinedInputRel = std::min(combinedInputRel, rel); + + + //calculate the cross reliability for this slave agent + float realCrossReliabilityOfSlaveAgent = crossReliabilityNEW(sA, mountedSlaveAgents, CONJUNCTION, 0); //AVERAGE, MULTIPLICATION, CONJUNCTION (best to worst: AVERAGE = CONJUNCTION > MULTIPLICATION >> ) + + //send all theoritcally possible scores to slave agent + + sA->pass_msgToSendBuffer(ISA_SuggestedAbstractedSensoryDataAndReliability); + for (int theoreticalScore = 0; theoreticalScore <= 3; theoreticalScore++) { + //calculate the cross reliability for this slave agent + float theoreticalCrossReliabilityOfSlaveAgent = crossReliabilityNEW(sA, mountedSlaveAgents, CONJUNCTION_THEORETICAL, theoreticalScore); //AVERAGE_THEORETICAL, MULTIPLICATION_THEORETICAL, CONJUNCTION_THEORETICAL (best to worst: AVERAGE_THEORETICAL = CONJUNCTION_THEORETICAL > MULTIPLICATION_THEORETICAL >> ) + sA->pass_msgToSendBuffer(theoreticalScore); + sA->pass_msgToSendBuffer(theoreticalCrossReliabilityOfSlaveAgent); + } + sA->send_msgs(); + + + combinedCrossRel = std::min(combinedCrossRel, realCrossReliabilityOfSlaveAgent); + + numOfSlaveAgentsWereChecked++; + } + + //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); + } + }; + } // namespace agent +}// namespace rosa #endif // !ROSA_AGENT_RELIABILITY_H diff --git a/lib/agent/Reliability.cpp b/lib/agent/Reliability.cpp new file mode 100644 index 0000000..e437136 --- /dev/null +++ b/lib/agent/Reliability.cpp @@ -0,0 +1,20 @@ +//===-- agent/Reliability.cpp -----------------------------------*- C++ -*-===// +// +// The RoSA Framework +// +//===----------------------------------------------------------------------===// +/// +/// \file agent/Reliability.cpp +/// +/// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at) +/// +/// \date 2019 +/// +/// \brief Implementation for rosa/agent/Reliability.h +/// +/// \note Empty implementation, source file here to have a compile database +/// entry for rosa/agent/Reliability.h +/// +//===----------------------------------------------------------------------===// + +#include "rosa/agent/Reliability.h"