Learning to Prevent Monocular SLAM Failure using Reinforcement Learning

Monocular SLAM refers to using a single camera to estimate robot ego motion while building a map of the environment. While Monocular SLAM is a well studied problem, automating Monocular SLAM by integrating it with trajectory planning frameworks is particularly challenging. This paper presents a novel formulation based on Reinforcement Learning (RL) that generates fail safe trajectories wherein the SLAM generated outputs do not deviate largely from their true values. Quintessentially, the RL framework successfully learns the otherwise complex relation between perceptual inputs and motor actions and uses this knowledge to generate trajectories that do not cause failure of SLAM. We show systematically in simulations how the quality of the SLAM dramatically improves when trajectories are computed using RL. Our method scales effectively across Monocular SLAM frameworks in both simulation and in real world experiments with a mobile robot.Comment: Accepted at the 11th Indian Conference on Computer Vision, Graphics and Image Processing (ICVGIP) 2018 More info can be found at the project page at https://robotics.iiit.ac.in/people/vignesh.prasad/SLAMSafePlanner.html and the supplementary video can be found at https://www.youtube.com/watch?v=420QmM_Z8v

Working Notes from the 1992 AAAI Spring Symposium on Practical Approaches to Scheduling and Planning

The symposium presented issues involved in the development of scheduling systems that can deal with resource and time limitations. To qualify, a system must be implemented and tested to some degree on non-trivial problems (ideally, on real-world problems). However, a system need not be fully deployed to qualify. Systems that schedule actions in terms of metric time constraints typically represent and reason about an external numeric clock or calendar and can be contrasted with those systems that represent time purely symbolically. The following topics are discussed: integrating planning and scheduling; integrating symbolic goals and numerical utilities; managing uncertainty; incremental rescheduling; managing limited computation time; anytime scheduling and planning algorithms, systems; dependency analysis and schedule reuse; management of schedule and plan execution; and incorporation of discrete event techniques

Analysis and Observations from the First Amazon Picking Challenge

This paper presents a overview of the inaugural Amazon Picking Challenge along with a summary of a survey conducted among the 26 participating teams. The challenge goal was to design an autonomous robot to pick items from a warehouse shelf. This task is currently performed by human workers, and there is hope that robots can someday help increase efficiency and throughput while lowering cost. We report on a 28-question survey posed to the teams to learn about each team's background, mechanism design, perception apparatus, planning and control approach. We identify trends in this data, correlate it with each team's success in the competition, and discuss observations and lessons learned based on survey results and the authors' personal experiences during the challenge

Identification of Design Principles

This report identifies those design principles for a (possibly new) query and transformation language for the Web supporting inference that are considered essential. Based upon these design principles an initial strawman is selected. Scenarios for querying the Semantic Web illustrate the design principles and their reflection in the initial strawman, i.e., a first draft of the query language to be designed and implemented by the REWERSE working group I4

Multithreaded Multiway Constraint Systems with Rust and WebAssembly

User interfaces are difficult to get right, and implementing and maintaining them takes up a significant portion of development time. Ensuring that all dependencies between Graphical User Interface (GUI) widgets are maintained, such as the value of one being computed from another, can be challenging and prone to bugs with a standard callback-based approach. The dependency graph formed from relations and constraints between variables quickly becomes unwieldy for humans, especially with multi-directional dataflow and transitive dependencies. HotDrink is a library for declaratively modeling constraints between widgets as a constraint system. This model includes information about how to enforce the constraints, which the library can use to automatically enforce them when values are changed, a process called solving. The programmer can thus focus on individual constraints without being distracted by their effect on the rest of the system. Previous implementations of HotDrink have been written in TypeScript and Flow, but they sometimes suffer from poor performance in larger constraint systems. In this project, we have explored the design space of constraint-based GUI programming for web applications, with a focus on static typing and multithreading. We have developed the library hotdrink-rs, a version of HotDrink implemented in Rust. To improve the performance of the planning step of solving, we have used an optimization technique called pruning that can speed up planning by several orders of magnitude. This enables use of the library for modeling larger systems, and for more performance-sensitive tasks. Our implementation falls short in systems where this optimization is not effective, which suggests that experiments with further optimizations, e.g., incremental planning algorithms, should be done. The library also supports multithreaded execution of plans, which both speeds up solving and guarantees GUI responsiveness in the face of long-running computations. The GUI is thus also more resilient to programmer mistakes that cause long-running or non-terminating computations. We have also developed hotdrink-wasm, a library that wraps data structures from hotdrink-rs to allow the library to be compiled to WebAssembly. hotdrink-wasm supports the use of Web Worker-based threads for multithreaded constraint system solving with cancelable computations in web applications. Finally, we present more memory-efficient data structures for constraint systems by representing variable indices with individual bits. In addition to saving memory, it may also provide performance benefits by being more cache-friendly.Masteroppgave i Programutvikling samarbeid med HVLPROG399MAMN-PRO

Taming Numbers and Durations in the Model Checking Integrated Planning System

The Model Checking Integrated Planning System (MIPS) is a temporal least commitment heuristic search planner based on a flexible object-oriented workbench architecture. Its design clearly separates explicit and symbolic directed exploration algorithms from the set of on-line and off-line computed estimates and associated data structures. MIPS has shown distinguished performance in the last two international planning competitions. In the last event the description language was extended from pure propositional planning to include numerical state variables, action durations, and plan quality objective functions. Plans were no longer sequences of actions but time-stamped schedules. As a participant of the fully automated track of the competition, MIPS has proven to be a general system; in each track and every benchmark domain it efficiently computed plans of remarkable quality. This article introduces and analyzes the most important algorithmic novelties that were necessary to tackle the new layers of expressiveness in the benchmark problems and to achieve a high level of performance. The extensions include critical path analysis of sequentially generated plans to generate corresponding optimal parallel plans. The linear time algorithm to compute the parallel plan bypasses known NP hardness results for partial ordering by scheduling plans with respect to the set of actions and the imposed precedence relations. The efficiency of this algorithm also allows us to improve the exploration guidance: for each encountered planning state the corresponding approximate sequential plan is scheduled. One major strength of MIPS is its static analysis phase that grounds and simplifies parameterized predicates, functions and operators, that infers knowledge to minimize the state description length, and that detects domain object symmetries. The latter aspect is analyzed in detail. MIPS has been developed to serve as a complete and optimal state space planner, with admissible estimates, exploration engines and branching cuts. In the competition version, however, certain performance compromises had to be made, including floating point arithmetic, weighted heuristic search exploration according to an inadmissible estimate and parameterized optimization