knowrob::DataDrivenReasoner Class Reference

#include <DataDrivenReasoner.h>

Inheritance diagram for knowrob::DataDrivenReasoner:

Collaboration diagram for knowrob::DataDrivenReasoner:

Public Types
enum	Feature {   NothingSpecial = 1 << 0 , UpdatesItself = 1 << 1 , InvalidatesItself = 1 << 2 , NothingSpecial = 1 << 0 ,   UpdatesItself = 1 << 1 , InvalidatesItself = 1 << 2 }
enum	Feature {   NothingSpecial = 1 << 0 , UpdatesItself = 1 << 1 , InvalidatesItself = 1 << 2 , NothingSpecial = 1 << 0 ,   UpdatesItself = 1 << 1 , InvalidatesItself = 1 << 2 }

Public Member Functions
	DataDrivenReasoner ()
void	enableFeature (Feature feature)
bool	hasFeature (Feature feature) const
void	setUpdateInterval (double intervalInSeconds)
auto	updateInterval () const
void	emit (const std::shared_ptr< reasoner::Event > &event)
void	observe (const std::shared_ptr< GraphQuery > &query, const BindingsHandler &handler)
void	observe (const std::string &queryString, const BindingsHandler &handler)
virtual void	update ()=0
virtual void	start ()
virtual void	stop ()
	DataDrivenReasoner ()
void	enableFeature (Feature feature)
bool	hasFeature (Feature feature) const
void	setUpdateInterval (double intervalInSeconds)
auto	updateInterval () const
void	emit (const std::shared_ptr< reasoner::Event > &event)
void	observe (const std::shared_ptr< GraphQuery > &query, const BindingsHandler &handler)
void	observe (const std::string &queryString, const BindingsHandler &handler)
virtual void	update ()=0
virtual void	start ()
virtual void	stop ()
Public Member Functions inherited from knowrob::Reasoner
	Reasoner ()
virtual	~Reasoner ()=default
auto &	reasonerName () const
auto	reasonerLanguage () const
auto	storage () const
template<class T >
std::shared_ptr< T >	getTypedStorage () const
ReasonerManager &	reasonerManager () const
void	pushWork (const std::function< void(void)> &fn)
void	setStorage (const StoragePtr &storage)
virtual bool	initializeReasoner (const PropertyTree &ptree)=0
virtual void	unload ()
	Reasoner ()
virtual	~Reasoner ()=default
auto &	reasonerName () const
auto	reasonerLanguage () const
auto	storage () const
template<class T >
std::shared_ptr< T >	getTypedStorage () const
ReasonerManager &	reasonerManager () const
void	pushWork (const std::function< void(void)> &fn)
void	setStorage (const StoragePtr &storage)
virtual bool	initializeReasoner (const PropertyTree &ptree)=0
virtual void	unload ()
Public Member Functions inherited from knowrob::DataSourceHandler
	DataSourceHandler ()=default
virtual	~DataSourceHandler ()=default
void	addDataHandler (const std::string &format, const DataSourceLoader &fn)
bool	loadDataSource (const DataSourcePtr &dataSource)
bool	hasDataHandler (const DataSourcePtr &dataSource) const
	DataSourceHandler ()=default
virtual	~DataSourceHandler ()=default
void	addDataHandler (const std::string &format, const DataSourceLoader &fn)
bool	loadDataSource (const DataSourcePtr &dataSource)
bool	hasDataHandler (const DataSourcePtr &dataSource) const

Protected Member Functions
void	processAssertion (const std::vector< TriplePtr > &triples)
void	processRetraction (const std::vector< TriplePtr > &triples)
void	processReplacement (const std::vector< TriplePtr > &triples)
void	processInvalidation ()
void	setReasonerOrigin (const std::vector< TriplePtr > &triples)
void	doUpdate ()
void	queueUpdate ()
void	processAssertion (const std::vector< TriplePtr > &triples)
void	processRetraction (const std::vector< TriplePtr > &triples)
void	processReplacement (const std::vector< TriplePtr > &triples)
void	processInvalidation ()
void	setReasonerOrigin (const std::vector< TriplePtr > &triples)
void	doUpdate ()
void	queueUpdate ()
Protected Member Functions inherited from knowrob::DataSourceHandler
virtual bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &)
virtual bool	loadDataSourceWithUnknownFormat (const DataSourcePtr &)

Protected Attributes
bool	isUpdateQueued_ = false
bool	isRunning_ = false
bool	isInvalidated_ = true
std::chrono::duration< double >	updateInterval_ = std::chrono::seconds(1)
uint32_t	features_ = NothingSpecial
std::set< TriplePtr >	inferredTriples_
std::shared_ptr< ThreadPool::Runner >	updateRunner_
std::chrono::time_point< std::chrono::high_resolution_clock >	lastUpdate_
Protected Attributes inherited from knowrob::DataSourceHandler
std::map< std::string, DataSourceLoader >	dataSourceHandler_

Detailed Description

A reasoner that is driven by data, i.e., it starts with the data and infers additional knowledge e.g. by applying rules to the data. This is in contrast to a goal-driven reasoner, which is driven by queries. The data is taken from a data backend, which is associated with the reasoner before the reasoner is started.

Definition at line 20 of file DataDrivenReasoner.h.

Member Enumeration Documentation

Feature [1/2]

enum knowrob::DataDrivenReasoner::Feature

Features of the reasoner.

Enumerator
NothingSpecial
UpdatesItself
InvalidatesItself
NothingSpecial
UpdatesItself
InvalidatesItself

Definition at line 25 of file DataDrivenReasoner.h.

                     {
            // The reasoner does not have any special features.
            NothingSpecial = 1 << 0,
            // The reasoner updates itself, thus `update` does not need to be called externally.
            UpdatesItself = 1 << 1,
            // The reasoner invalidates itself, thus `update` does not need to be called periodically
            // in case no invalidation happens.
            InvalidatesItself = 1 << 2
        };

Feature [2/2]

enum knowrob::DataDrivenReasoner::Feature

Features of the reasoner.

Enumerator
NothingSpecial
UpdatesItself
InvalidatesItself
NothingSpecial
UpdatesItself
InvalidatesItself

Definition at line 25 of file DataDrivenReasoner.h.

                     {
            // The reasoner does not have any special features.
            NothingSpecial = 1 << 0,
            // The reasoner updates itself, thus `update` does not need to be called externally.
            UpdatesItself = 1 << 1,
            // The reasoner invalidates itself, thus `update` does not need to be called periodically
            // in case no invalidation happens.
            InvalidatesItself = 1 << 2
        };

Constructor & Destructor Documentation

DataDrivenReasoner() [1/2]

DataDrivenReasoner::DataDrivenReasoner

(

)

Definition at line 15 of file DataDrivenReasoner.cpp.

                                       {
    using StopChecker = ThreadPool::LambdaRunner::StopChecker;
    using Runner = ThreadPool::LambdaRunner;
    updateRunner_ = std::make_shared<Runner>([this](const StopChecker &) { doUpdate(); });
}

DataDrivenReasoner() [2/2]

knowrob::DataDrivenReasoner::DataDrivenReasoner

(

)

Member Function Documentation

doUpdate() [1/2]

void DataDrivenReasoner::doUpdate ( )

protected

Definition at line 43 of file DataDrivenReasoner.cpp.

                                  {
    // do the update
    if (reasonerLanguage() == PluginLanguage::PYTHON) {
        // If the reasoner uses Python code, then we must make sure that the GIL is acquired in the current thread.
        py::gil_lock acquire;
        update();
    } else {
        update();
    }
    auto now = std::chrono::high_resolution_clock::now();
    isUpdateQueued_ = false;
    isInvalidated_ = false;
 
    if (!hasFeature(UpdatesItself) && !hasFeature(InvalidatesItself)) {
        // if the reasoner does not update itself and does not invalidate itself, then
        // periodically update the reasoner.
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastUpdate_);
        if (duration > updateInterval_) {
            // we cannot keep up with the update rate, so directly re-queue the update.
            queueUpdate();
        } else {
            auto remaining = std::chrono::milliseconds(
                    static_cast<int>(updateInterval_.count()) - duration.count());
            // Create a timer that triggers the update after the remaining time.
            // It is not optimal to create a new thread for each update though,
            // but it would be good to stick to the worker thread pool for performing the
            // update. However, the worker thread pool does not support delayed execution yet.
            // Note: this is done so to avoid calling sleep for the worker thread
            //       as it would block it from being used for other tasks.
            std::thread timeout([&remaining, this]() {
                std::this_thread::sleep_for(remaining);
                queueUpdate();
            });
            timeout.detach();
        }
    }
 
    lastUpdate_ = now;
}

doUpdate() [2/2]

void knowrob::DataDrivenReasoner::doUpdate ( )

protected

emit() [1/2]

void DataDrivenReasoner::emit

(

const std::shared_ptr< reasoner::Event > &

event

)

Trigger a reasoner event. This is the main way how the reasoner informs the rest of the system about its result and state.

Parameters

event

a reasoner event.

Definition at line 104 of file DataDrivenReasoner.cpp.

                                                                       {
    switch (event->eventType()) {
        case reasoner::Event::Assertion:
            processAssertion(std::static_pointer_cast<reasoner::AssertionEvent>(event)->triples());
            break;
        case reasoner::Event::Retraction:
            processRetraction(std::static_pointer_cast<reasoner::RetractionEvent>(event)->triples());
            break;
        case reasoner::Event::Replacement:
            processReplacement(std::static_pointer_cast<reasoner::ReplacementEvent>(event)->triples());
            break;
        case reasoner::Event::Invalidation:
            processInvalidation();
            break;
    }
}

emit() [2/2]

void knowrob::DataDrivenReasoner::emit

(

const std::shared_ptr< reasoner::Event > &

event

)

Trigger a reasoner event. This is the main way how the reasoner informs the rest of the system about its result and state.

Parameters

event

a reasoner event.

enableFeature() [1/2]

void DataDrivenReasoner::enableFeature

(

Feature

feature

)

Enable a feature of the reasoner.

Parameters

feature

a feature.

Definition at line 21 of file DataDrivenReasoner.cpp.

                                                      {
    features_ = features_ | static_cast<uint32_t>(feature);
}

enableFeature() [2/2]

void knowrob::DataDrivenReasoner::enableFeature

(

Feature

feature

)

Enable a feature of the reasoner.

Parameters

feature

a feature.

hasFeature() [1/2]

bool DataDrivenReasoner::hasFeature

(

Feature

feature

)

const

Returns

true if the reasoner has a feature.

Definition at line 25 of file DataDrivenReasoner.cpp.

                                                         {
    return (features_ & static_cast<uint32_t>(feature)) == static_cast<uint32_t>(feature);
}

hasFeature() [2/2]

bool knowrob::DataDrivenReasoner::hasFeature

(

Feature

feature

)

const

Returns

true if the reasoner has a feature.

observe() [1/4]

void DataDrivenReasoner::observe	(	const std::shared_ptr< GraphQuery > &	query,
		const BindingsHandler &	handler
	)

Observe a graph query. The reasoner will observe the query and call the handler whenever the query's result changes.

Parameters

query	a graph query.
handler	a bindings handler.

Definition at line 121 of file DataDrivenReasoner.cpp.

                                                                                                       {
    reasonerManager().kb()->observe(query, handler);
}

observe() [2/4]

void knowrob::DataDrivenReasoner::observe	(	const std::shared_ptr< GraphQuery > &	query,
		const BindingsHandler &	handler
	)

Observe a graph query. The reasoner will observe the query and call the handler whenever the query's result changes.

Parameters

query	a graph query.
handler	a bindings handler.

observe() [3/4]

void DataDrivenReasoner::observe	(	const std::string &	queryString,
		const BindingsHandler &	handler
	)

Observe a graph query. The reasoner will observe the query and call the handler whenever the query's result changes.

Parameters

queryString	a graph query string.
handler	a bindings handler.

Definition at line 125 of file DataDrivenReasoner.cpp.

                                                                                             {
    auto term = QueryParser::parseGraphTerm(queryString);
    auto query = std::make_shared<GraphQuery>(term);
    reasonerManager().kb()->observe(query, handler);
}

observe() [4/4]

void knowrob::DataDrivenReasoner::observe	(	const std::string &	queryString,
		const BindingsHandler &	handler
	)

Observe a graph query. The reasoner will observe the query and call the handler whenever the query's result changes.

Parameters

queryString	a graph query string.
handler	a bindings handler.

processAssertion() [1/2]

void DataDrivenReasoner::processAssertion ( const std::vector< TriplePtr > &  triples )

protected

Definition at line 148 of file DataDrivenReasoner.cpp.

                                                                             {
    setReasonerOrigin(triples);
    reasonerManager().kb()->insertAll(triples);
}

processAssertion() [2/2]

void knowrob::DataDrivenReasoner::processAssertion ( const std::vector< TriplePtr > &  triples )

protected

processInvalidation() [1/2]

void DataDrivenReasoner::processInvalidation ( )

protected

Definition at line 131 of file DataDrivenReasoner.cpp.

                                             {
    if (!hasFeature(InvalidatesItself)) {
        KB_WARN("Reasoner has no feature to invalidate itself, but still generated an invalidation event. Ignoring.");
        return;
    }
    if (!isInvalidated_) {
        isInvalidated_ = true;
        queueUpdate();
    }
}

processInvalidation() [2/2]

void knowrob::DataDrivenReasoner::processInvalidation ( )

protected

processReplacement() [1/2]

void DataDrivenReasoner::processReplacement ( const std::vector< TriplePtr > &  triples )

protected

Definition at line 158 of file DataDrivenReasoner.cpp.

                                                                               {
    setReasonerOrigin(triples);
 
    if (inferredTriples_.empty()) {
        inferredTriples_.insert(triples.begin(), triples.end());
        reasonerManager().kb()->insertAll(triples);
    } else {
        auto &oldTriples = inferredTriples_;
        // ensure that input triples are sorted which is required for set_difference
        std::set<TriplePtr> newTriples(triples.begin(), triples.end());
 
        std::vector<TriplePtr> triplesToRemove, triplesToAdd;
        // old inferences without new inferences are the ones that do not hold anymore.
        std::set_difference(oldTriples.begin(), oldTriples.end(),
                            newTriples.begin(), newTriples.end(),
                            std::inserter(triplesToRemove, triplesToRemove.begin()));
        // new inferences without old inferences are the ones that are really new.
        std::set_difference(newTriples.begin(), newTriples.end(),
                            oldTriples.begin(), oldTriples.end(),
                            std::inserter(triplesToAdd, triplesToAdd.begin()));
        // update the set of inferred triples.
        for (auto &triple: triplesToRemove) {
            inferredTriples_.erase(triple);
        }
        inferredTriples_.insert(triplesToAdd.begin(), triplesToAdd.end());
        // update the knowledge base
        if (!triplesToAdd.empty()) {
            reasonerManager().kb()->insertAll(triplesToAdd);
        }
        if (!triplesToRemove.empty()) {
            reasonerManager().kb()->removeAll(triplesToRemove);
        }
    }
}

processReplacement() [2/2]

void knowrob::DataDrivenReasoner::processReplacement ( const std::vector< TriplePtr > &  triples )

protected

processRetraction() [1/2]

void DataDrivenReasoner::processRetraction ( const std::vector< TriplePtr > &  triples )

protected

Definition at line 153 of file DataDrivenReasoner.cpp.

                                                                              {
    setReasonerOrigin(triples);
    reasonerManager().kb()->removeAll(triples);
}

processRetraction() [2/2]

void knowrob::DataDrivenReasoner::processRetraction ( const std::vector< TriplePtr > &  triples )

protected

queueUpdate() [1/2]

void DataDrivenReasoner::queueUpdate ( )

protected

Definition at line 33 of file DataDrivenReasoner.cpp.

                                     {
    if (isUpdateQueued_) return;
    isUpdateQueued_ = true;
    DefaultThreadPool()->pushWork(
            updateRunner_,
            [](const std::exception &exc) {
                KB_ERROR("Error in reasoner update: {}", exc.what());
            });
}

queueUpdate() [2/2]

void knowrob::DataDrivenReasoner::queueUpdate ( )

protected

setReasonerOrigin() [1/2]

void DataDrivenReasoner::setReasonerOrigin ( const std::vector< TriplePtr > &  triples )

protected

Definition at line 142 of file DataDrivenReasoner.cpp.

                                                                              {
    for (auto &triple: triples) {
        triple.ptr->setGraph(reasonerName()->stringForm());
    }
}

setReasonerOrigin() [2/2]

void knowrob::DataDrivenReasoner::setReasonerOrigin ( const std::vector< TriplePtr > &  triples )

protected

setUpdateInterval() [1/2]

void DataDrivenReasoner::setUpdateInterval

(

double

intervalInSeconds

)

Set the update rate of the reasoner. Only used if update is called externally.

Parameters

intervalInSeconds

the update interval in seconds.

Definition at line 29 of file DataDrivenReasoner.cpp.

                                                                   {
    updateInterval_ = std::chrono::duration<double>(intervalInSeconds);
}

setUpdateInterval() [2/2]

void knowrob::DataDrivenReasoner::setUpdateInterval

(

double

intervalInSeconds

)

Set the update rate of the reasoner. Only used if update is called externally.

Parameters

intervalInSeconds

the update interval in seconds.

start() [1/2]

void DataDrivenReasoner::start ( )

virtual

Start calling the update function periodically.

Definition at line 83 of file DataDrivenReasoner.cpp.

                               {
    // Only start if not already running
    if (isRunning_) return;
    isRunning_ = true;
    // update the reasoner if it does not update itself
    if (!hasFeature(UpdatesItself)) {
        queueUpdate();
    }
}

start() [2/2]

virtual void knowrob::DataDrivenReasoner::start ( )

virtual

Start calling the update function periodically.

stop() [1/2]

void DataDrivenReasoner::stop ( )

virtual

Stop calling the update function.

Definition at line 93 of file DataDrivenReasoner.cpp.

                              {
    if (!isRunning_) return;
    isRunning_ = false;
    // stop the periodic updating
    if (!hasFeature(UpdatesItself)) {
        if (updateRunner_ && !updateRunner_->isTerminated()) {
            updateRunner_->stop(false);
        }
    }
}

stop() [2/2]

virtual void knowrob::DataDrivenReasoner::stop ( )

virtual

Stop calling the update function.

update() [1/2]

virtual void knowrob::DataDrivenReasoner::update ( )

pure virtual

Update the reasoner. This function is called periodically to update the reasoner's state in case the reasoner does not update itself (see enableFeature).

update() [2/2]

virtual void knowrob::DataDrivenReasoner::update ( )

pure virtual

Update the reasoner. This function is called periodically to update the reasoner's state in case the reasoner does not update itself (see enableFeature).

updateInterval() [1/2]

auto knowrob::DataDrivenReasoner::updateInterval ( ) const

inline

Returns

the update interval of the reasoner.

Definition at line 58 of file DataDrivenReasoner.h.

{ return updateInterval_; }

updateInterval() [2/2]

auto knowrob::DataDrivenReasoner::updateInterval ( ) const

inline

Returns

the update interval of the reasoner.

Definition at line 58 of file DataDrivenReasoner.h.

{ return updateInterval_; }

Member Data Documentation

features_

uint32_t knowrob::DataDrivenReasoner::features_ = NothingSpecial

protected

Definition at line 106 of file DataDrivenReasoner.h.

inferredTriples_

std::set< TriplePtr > knowrob::DataDrivenReasoner::inferredTriples_

protected

Definition at line 107 of file DataDrivenReasoner.h.

isInvalidated_

bool knowrob::DataDrivenReasoner::isInvalidated_ = true

protected

Definition at line 104 of file DataDrivenReasoner.h.

isRunning_

bool knowrob::DataDrivenReasoner::isRunning_ = false

protected

Definition at line 103 of file DataDrivenReasoner.h.

isUpdateQueued_

bool knowrob::DataDrivenReasoner::isUpdateQueued_ = false

protected

Definition at line 102 of file DataDrivenReasoner.h.

lastUpdate_

std::chrono::time_point< std::chrono::high_resolution_clock > knowrob::DataDrivenReasoner::lastUpdate_

protected

Definition at line 109 of file DataDrivenReasoner.h.

updateInterval_

std::chrono::duration< double > knowrob::DataDrivenReasoner::updateInterval_ = std::chrono::seconds(1)

protected

Definition at line 105 of file DataDrivenReasoner.h.

updateRunner_

std::shared_ptr< ThreadPool::Runner > knowrob::DataDrivenReasoner::updateRunner_

protected

Definition at line 108 of file DataDrivenReasoner.h.

---

The documentation for this class was generated from the following files:

• build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/reasoner/DataDrivenReasoner.h
• src/reasoner/DataDrivenReasoner.cpp