Nowadays remarkable progress has been observed in facial detection as a core part of computer vision. Nevertheless, motion blur still presents substantial challenges in face detection. The most recent face image deblurring methods make oversimplifying presumption and fail to restore the highly structured face shape/identity information. Therefore, we propose a data-driven based face image deblurring approach that foster facial detection and identity preservation. The proposed model includes two sequential data streams: Out of any supervision the first has been trained on real unlabeled clear/blurred data to generate a close realistic blurred image data during its inference. On the other hand, the generated labeled data has been exploited with by a second supervised learning-based data steam to learn the mapping function from blur domain to the clear one. We utilize the restored data to conduct an experimentation on face detection task. The experimental evaluation demonstrates the outperformance of our results and supports our system design and training strategy.
Logical reasoning as performed by human mathematicians involves an intuitive under- standing of terms and formulas. This includes properties of formulas themselves as well as relations between multiple formulas. Although vital, this intuition is missing when supplying atomically encoded formulae to (neural) down-stream models. In this paper we construct continuous dense vector representations of first-order logic which preserve syntactic and semantic logical properties. The resulting neural formula embeddings encode six characteristics of logical expressions present in the training-set and further generalise to properties they have not explicitly been trained on. To facilitate training, evaluation, and comparing of embedding models we extracted and generated data sets based on TPTP’s first-order logic library. Furthermore we examine the expressiveness of our encodings by conducting toy-task as well as more practical deployment tests.
Domain-oriented knowledge bases (KBs) such as DBpedia and YAGO are largely constructed by applying a set of predefined extraction rules to the semi-structured contents of Wikipedia articles. Although both of these large-scale KBs achieve very high average precision values (above 95% for YAGO3), subtle mistakes in a few of the underlying ex- traction rules may still impose a substantial amount of systematic extraction mistakes for specific relations. For example, by applying the same regular expressions to extract per- son names of both Asian and Western nationality, YAGO erroneously swaps most of the family and given names of Asian person entities. For traditional rule-learning approaches based on Inductive Logic Programming (ILP), it is very difficult to detect these systematic extraction mistakes, since they usually occur only in a relatively small subdomain of the relations’ arguments. In this paper, we thus propose a guided form of ILP, coined “GILP”, that iteratively asks for small amounts of user feedback over a given KB to learn a set of data-cleaning rules that (1) best match the feedback and (2) also generalize to a larger portion of facts in the KB. We propose both algorithms and respective metrics to automatically assess the quality of the learned rules with respect to the user feedback.
Various sub-symbolic approaches for reasoning and learning have been proposed in the literature. Among these approaches, the neural theorem prover (NTP) approach uses a backward chaining reasoning mechanism to guide a machine learning architecture to learn vector embedding representations of predicates and to induce first-order clauses from a given knowledge base. NTP is however known for being not scalable, as the computation trees generated by the backward chaining process can grow exponentially with the size of the given knowledge base. In this paper we address this limitation by extending the NTP approach with a topic-based method for controlling the induction of first-order clauses. Our proposed approach, called TNTP for Topical NTP, identifies topic-based clusters over a large knowledge-base and uses these clusters to control the soft unification of predicates during the learning process with the effect of reducing the size of the computation tree needed to induce first-order clauses. Our TNTP framework is capable of learning a diverse set of induced rules that have improved predictive accuracy, whilst reducing the computational time by several orders of magnitude. We demonstrated this by evaluating our approach on three different datasets (UMLS, Kinship and Nations) and comparing our results with that of the NTP method, chosen here as our baseline.
The Winograd Schema Challenge (WSC), the task of resolving pronouns in certain carefully-structured sentences, has received considerable interest in the past few years as an alternative to the Turing Test. In our recent work we demonstrated the plausibility of using commonsense knowledge, automatically acquired from raw text in English Wikipedia, towards computing a metric of hardness for a limited number of Winograd Schemas. In this work we present WinoReg, a new system to compute hardness of Winograd Schemas, by training a Random Forest classifier over a rich set of features identified in relevant WSC works in the literature. Our empirical study shows that this new system is considerably faster and more accurate compared to the system proposed in our earlier work, making its use as part of other WSC-based systems feasible.
This paper discusses the tragic accident in which the first pedestrian was killed by an autonomous car: due to several grave errors in its design, it failed to recognize the pedestrian and stop in time to avoid a collision. We start by discussing the accident in some detail, enlightened by the recent publication of a report from the National Transportation Safety Board (NTSB) re. the accident. We then discuss the shortcomings of current autonomous- car technology, and advocate an approach in which several AI agents generate arguments in support of some action, and an adjudicator AI determines which course of action to take. Input to the agents can come from both symbolic reasoning and connectionist-style inference. Either way, underlying each argument and the adjudication process is a proof/argument in the language of a multi-operator modal calculus, which renders transparent both the mechanisms of the AI and accountability when accidents happen.
We recall the epistemic logic S5r for reasoning about knowledge under hypotheses and we investigate the extension of the logic with an operator for common knowledge. The logic S5r is equipped with a modal operator of necessity that can be parameterized with hypotheses representing background assumptions while the extension with the common knowledge operator enables us to describe and reason about common knowledge among agents with possibly different background assumptions. We present an axiomatization of the logic and prove Kripke completeness and decidability results.
This paper introduces, philosophically and to a degree formally, the novel concept of learn- ing ex nihilo, intended (obviously) to be analogous to the concept of creation ex nihilo. Learning ex nihilo is an agent’s learning “from nothing”, by the suitable employment of inference schemata for deductive and inductive reasoning. This reasoning must be in machine-verifiable accord with a formal proof/argument theory in a cognitive calculus (i.e., here, roughly, an intensional higher-order multi-operator quantified logic), and this reasoning is applied to percepts received by the agent, in the context of both some prior knowledge, and some prior and current interests. Learning ex nihilo is a challenge to con- temporary forms of ML, indeed a severe one, but the challenge is here offered in the spirit of seeking to stimulate attempts, on the part of non-logicist ML researchers and engineers, to collaborate with those in possession of learning-ex nihilo frameworks, and eventually attempts to integrate directly with such frameworks at the implementation level. Such integration will require, among other things, the symbiotic interoperation of state-of-the- art automated reasoners and high-expressivity planners, with statistical/connectionist ML technology.
Resolution and superposition are common techniques which have seen widespread use with propositional and first-order logic in modern theorem provers. In these cases, resolution proof production is a key feature of such tools; however, the proofs that they produce are not necessarily as concise as possible. For propositional resolution proofs, there are a wide variety of proof compression techniques. There are fewer techniques for compressing first-order resolution proofs generated by automated theorem provers. This paper describes an approach to compressing first-order logic proofs based on lifting proof compression ideas used in propositional logic to first-order logic. One method for propositional proof compression is partial regularization, which removes an inference n when it is redundant in the sense that its pivot literal already occurs as the pivot of another inference in every path from n to the root of the proof. This paper describes the generalization of the partial-regularization algorithm RecyclePivotsWithIntersection [10] from propositional logic to first-order logic. An empirical evaluation of the generalized algorithm and its combinations with the previously lifted GreedyLinearFirstOrderLowerUnits algorithm [12] is also presented.
In this paper we investigate two hypothesis regarding the use of deep reinforcement learning in multiple tasks. The first hypothesis is driven by the question of whether a deep reinforcement learning algorithm, trained on two similar tasks, is able to outperform two single-task, individually trained algorithms, by more efficiently learning a new, similar task, that none of the three algorithms has encountered before. The second hypothesis is driven by the question of whether the same multi-task deep RL algorithm, trained on two similar tasks and augmented with elastic weight consolidation (EWC), is able to retain similar performance on the new task, as a similar algorithm without EWC, whilst being able to overcome catastrophic forgetting in the two previous tasks. We show that a multi-task Asynchronous Advantage Actor-Critic (GA3C) algorithm, trained on Space Invaders and Demon Attack, is in fact able to outperform two single-tasks GA3C versions, trained individually for each single-task, when evaluated on a new, third task—namely, Phoenix. We also show that, when training two trained multi-task GA3C algorithms on the third task, if one is augmented with EWC, it is not only able to achieve similar performance on the new task, but also capable of overcoming a substantial amount of catastrophic forgetting on the two previous tasks.
Active Learning is concerned with the question of how to identify the most useful samples for a Machine Learning algorithm to be trained with. When applied correctly, it can be a very powerful tool to counteract the immense data requirements of Artificial Neural Networks. However, we find that it is often applied with not enough care and domain knowledge. As a consequence, unrealistic hopes are raised and transfer of the experimental results from one dataset to another becomes unnecessarily hard. In this work we analyse the robustness of different Active Learning methods with respect to classifier capacity, exchangeability and type, as well as hyperparameters and falsely labelled data. Experiments reveal possible biases towards the architecture used for sample selection, resulting in suboptimal performance for other classifiers. We further propose the new ”Sum of Squared Logits” method based on the Simpson diversity index and investigate the effect of using the confusion matrix for balancing in sample selection.
We study a family of operators (called ‘Tooth’ operators) that combine Description Logic concepts via weighted sums. These operators are intended to capture the notion of instances satisfy- ing “enough” of the concept descriptions given. We examine two variants of these operators: the “knowledge-independent” one, that evaluates the concepts with respect to the current interpretation, and the “knowledge-dependent” one that instead evaluates them with respect to a specified knowledge base, comparing and contrasting their properties. We furthermore discuss the connections between these operators and linear classification models.
In propositional model counting, also named #SAT, the search space needs to be explored exhaustively, in contrast to SAT, where the task is to determine whether a propositional formula is satisfiable. While state-of-the-art SAT solvers are based on non- chronological backtracking, it has also been shown that backtracking chronologically does not significantly degrade solver performance. Hence investigating the combination of chronological backtracking with conflict-driven clause learning (CDCL) for #SAT seems evident. We present a calculus for #SAT combining chronological backtracking with CDCL and provide a formal proof of its correctness.
The multi-agent path finding (MAPF) problem is a combinatorial search problem that aims at finding paths for multiple agents such that no two agents collide with each other. We study a dynamic variant of MAPF, called D-MAPF, which allows changes in the environment (e.g., some existing obstacles may be removed from the environment or moved to some other location, or new obstacles may be included in the environment), and/or changes in the team (e.g., some existing agents may leave and some new agents may join the team) at different times. We introduce a new method to solve D-MAPF, using answer set programming.
Reverse engineering queries from given data, as in the case of query-by-example and query definability, is an important problem with many applications that has recently gained attention in the areas where symbolic artificial intelligence meets learning. In the presence of ontologies this problem was recently studied for Horn-ALC and Horn-ALCI. The main contribution of this paper is to take a first look at the case of DL-Lite, to identify cases where the addition of the ontology does not increase the worst-case complexity of the problem. Unfortunately, reverse engineering conjunctive queries is known to be very hard, even for plain databases, since the smallest witness query is known to be exponential in general. In the light of this, we outline some possible research directions for exploiting the ontology in order to obtain smaller witness queries.
Temporal dataset evaluation is the problem of establishing to what extent a set of temporal data (histories) complies with a given temporal condition. Checking interval temporal logic formulas against a finite model has been recently proposed, and proved successful, as a tool to solve such a problem. In this paper, we address the problem of checking interval temporal logic specifications, supporting interval length constraints, against infinite, finitely representable models, and we show the applicability of the resulting procedure to the evaluation of incomplete temporal datasets viewed as finite prefixes of ultimately-periodic histories.
We summarise the definitions and some technical aspects of a familiy of description logics that introduce concept constructors (so-called tooth-operators) which, under various constraints, accumulate weights of concepts. We demonstrate how these operators can be fruitfully and elegantly applied to a number of cognitively motivated classification problems which are difficult to handle with the standard expressive means of description logics.
In the context of computer vision, most of the traditional action recognition techniques assign a single label to a video after analyzing the whole video. We believe that under- standing of the visual world is not limited to recognizing a specific action class or individual object instances, but also extends to how those objects interact in the scene, which im- plies recognizing events happening in the scene. In this paper we present an approach for identifying complex events in videos, starting from detection of objects and simple events using a state-of-the-art object detector (YOLO). We provide a logic based representation of events by using a realization of the Event calculus that allows us to define complex events in terms of logical rules. Axioms of the calculus are encoded in a logic program under Answer Set semantics in order to reason and formulate queries over the extracted events. The applicability of the framework is demonstrated over the scenario of recognizing different kinds of kick events in soccer videos.
This paper deals with querying ontology-based knowledge bases equipped with non-monotonic rules through a case study within the framework of Cultural Heritage. It focuses on 3D underwater surveys on the Xlendi wreck which is represented by an OWL2 knowledge base with a large dataset. The paper aims at improving the interactions between the archaeologists and the knowledge base providing new queries that involve non-monotonic rules in order to perform qualitative spatial reasoning. To this end, the knowledge base initially represented in OWL2-QL is translated into an equivalent Answer Set Programming (ASP) program and is enriched with a set of non-monotonic ASP rules suitable to express default and exceptions. An ASP query answering approach is proposed and implemented. Furthermore due to the increased expressiveness of non-monotonic rules it provides spatial reasoning and spatial relations between artifacts query answering which is not possible with query answering languages such as SPARQL and SQWRL.
DLS-Forgetter is a reasoning tool that aims to compute restricted views of a knowledge base of first-order logic formulae via semantic forgetting. Semantic forgetting achieves this by eliminating predicate symbols in an equivalence preserving way up to the remaining symbols. Forgetting has many applications such as information hiding, explanation generation and computing logical difference. DLS-Forgetter combines ideas from two Ackermann-based approaches: the DLS algorithm and a modal logic inference system inspired by the algorithm. The tool enhances the DLS algorithm by incorporating an ordering over the symbols in the forgetting signature. This allows more control over the forgetting process and the application of the elimination rules. The theory behind the tool is provided by a first-order Ackermann calculus, a first-order generalisation of the rules outlined by the modal logic inference system. The purpose of the tool is to provide the research community with an experimental tool to allow further research to be conducted in the area. This paper describes the DLS-Forgetter tool along with its underlying calculus, it outlines the forgetting process used in the implementation, and presents results of an empirical evaluation.
