We introduce a new task called Adaptable Error Detection (AED), which aims to identify behavior errors in few-shot imitation (FSI) policies based on visual observations in novel environments. The potential to cause serious damage to surrounding areas limits the application of FSI policies in real-world scenarios. Thus, a robust system is necessary to notify operators when FSI policies are inconsistent with the intent of demonstrations. This task introduces three challenges: (1) detecting behavior errors in novel environments, (2) identifying behavior errors that occur without revealing notable changes, and (3) lacking complete temporal information of the rollout due to the necessity of online detection. However, the existing benchmarks cannot support the development of AED because their tasks do not present all these challenges. To this end, we develop a cross-domain AED benchmark, consisting of 322 base and 153 novel environments. Additionally, we propose Pattern Observer (PrObe) to address these challenges. PrObe is equipped with a powerful pattern extractor and guided by novel learning objectives to parse discernible patterns in the policy feature representations of normal or error states. Through our comprehensive evaluation, PrObe demonstrates superior capability to detect errors arising from a wide range of FSI policies, consistently surpassing strong baselines. Moreover, we conduct detailed ablations and a pilot study on error correction to validate the effectiveness of the proposed architecture design and the practicality of the AED task, respectively. The AED project page can be found at https://aed-neurips.github.io/.

A spatial AI that can perform complex tasks through visual signals and cooperate with humans is highly anticipated. To achieve this, we need a visual SLAM that easily adapts to new scenes without pre-training and generates dense maps for downstream tasks in real-time. None of the previous learning-based and non-learning-based visual SLAMs satisfy all needs due to the intrinsic limitations of their components. In this work, we develop a visual SLAM named Orbeez-SLAM, which successfully collaborates with implicit neural representation and visual odometry to achieve our goals. Moreover, Orbeez-SLAM can work with the monocular camera since it only needs RGB inputs, making it widely applicable to the real world. Results show that our SLAM is up to 800x faster than the strong baseline with superior rendering outcomes. Code link: https://github.com/MarvinChung/Orbeez-SLAM.

In few-shot imitation learning (FSIL), using behavioral cloning (BC) to solve unseen tasks with few expert demonstrations becomes a popular research direction. The following capabilities are essential in robotics applications: (1) Behaving in compound tasks that contain multiple stages. (2) Retrieving knowledge from few length-variant and misalignment demonstrations. (3) Learning from an expert different from the agent. No previous work can achieve these abilities at the same time. In this work, we conduct FSIL problem under the union of above settings and introduce a novel stage conscious attention network (SCAN) to retrieve knowledge from few demonstrations simultaneously. SCAN uses an attention module to identify each stage in length-variant demonstrations. Moreover, it is designed under demonstration-conditioned policy that learns the relationship between experts and agents. Experiment results show that SCAN can perform in complicated compound tasks without fine-tuning and provide the explainable visualization. Project page is at https://sites.google.com/view/scan-aaai2022.

Depth estimation is essential for many applications, such as 3D reconstruction and object recognition. In practice, the captured depth images naturally suffer from the noise and invalid depth value, i.e, depth noise and depth hole. Despite making a process on filling a small number (less than 10%) of depth holes, the performance of the prior depth reconstruction systems drops significantly when coping with the larger hole region (up to 25%). To tackle this, we propose a novel Sequential Depth Networks (SeqDNet). Instead of filling holes in coarse scale, our model tends to leverage the information in the spatial structures constructed from depth images. There are two novel components in the proposed SeqDNet: (1) We slice the depth map from near to far, generating the spatial structure, named sequential depth. It provides residual depth information, which was neglected in previous works. (2) The edge awareness loss (EA Loss) matches the gradient of the depth map by controlling the weight with the normal map so as to provide additional instruction (whether the position is the edge or not) when filling depth holes. Experimental results show a significant performance gain on filling images with 25% depth holes using SeqDNet. Moreover, a comprehensive analysis is given to pave a path for future researches addressing the large hole size on the depth maps.

Software testing methodologies and metrics are key issues to improve and assure software quality. They are important areas in the research of Software Engineering. However, not many focus on the testing criteria and metrics evaluation of a class hierarchy. This paper introduces an important concept named URI (Unit Repeated Inheritance) to realize integrated object-oriented testing and object-oriented metrics. The approach describes an ILT (Inheritance Level Technique) method as a guide to test object-oriented software errors and measure the software complexity of a class hierarchy. The proposed technique shows that inheritance has a close relation to object-oriented software complexity and reveals that overuse of repeated(multiple) inheritance will increase software complexity and be prone to implicit software errors. Also, two test criteria: intra level first and inter level first are presented.

Verification and validation are two important technologies to assure the reliability and quality of software. Software testing and metrics are two approaches to execute the verification and validation. In sequential computation, a fairly mature process exists, with various methodologies and tools available for use in building and demonstrating the correctness of a program being tested. The emergence of concurrent computation in recent years, however, introduces new testing problems and difficulties that cannot be solved by the traditional sequential program testing techniques. Many concurrent program testing methodologies have been proposed to solve controlled execution and determinism. There have been few discussions of concurrent software testing from the inter-task viewpoint, even though the common characteristics of concurrent programming are the explicit identification of the large-grain parallel computation units (tasks) and the explicit inter-task communication via a rendezvous-style mechanism. In this paper, we focus on testing concurrent programs through task decomposition. We propose four testing criteria to test a concurrent program. A programmer can choose an appropriate testing strategy depending on the properties of the concurrent programs. Associated with the strategies, four equations are provided to measure the complexity of concurrent programs.

Software testing and metrics are two important approaches to assure the reliability and quality of software. The emergence of concurrent programming in recent years introduces new testing problems and difficulties that cannot be solved by testing techniques for traditional sequential programs. One of the difficult tasks is that concurrent programs can have many instances of execution for the same set of input data. Many concurrent program testing methodologies propose to solve controlled execution and determinism. There are few discussions of concurrent software testing from the inter-task viewpoints. Yet, the common characteristics of concurrent programming are explicit identification of the large grain parallel computation units (tasks), and the explicit inter-task communication via rendezvous-style mechanisms. In this paper, we focus on testing concurrent programs through task decomposition. We propose four testing criteria to test a concurrent program. The programmer can choose an appropriate testing strategy depending on the properties of the concurrent program. Associated with the strategies, four equations are provided to measure the complexity of concurrent programs.

Many CASE (computer aided software engineering) tools have been developed to increase software productivity. Therefore, tool integration needed more investigation. This paper proposes an architecture based on a control integration platform for exchanging messages among different tools. This platform supports different tools to integrate into a cooperative software development environment easily. Some tools including a compiler, editor and testing path analyzer are integrated into this environment. Some evaluation criteria are illustrated to assess the proposed platform and their integrated tools.>

Inheritance is an important attribute in object-oriented programming (OOP). This notion supports the class hierarchy design and captures the is-a relationship between a class and its subclass. It contributes to food properties of modularity, reusability and incremental design. However, misuse of multiple (repeated) inheritance leads to an improper class hierarchy which suffers from name-conflict and implicit errors. This type of error is very difficult to detect by conventional testing methodologies. This paper describes a graph-theoretical testing methodology for detecting this type of error. An algorithm to support this testing methodology is also presented.>