The dominant paradigm for programming a computer today is text entry via keyboard and mouse, but there aremany common situations where this is not ideal. I address this through the creation of a new language thatis explicitly intended for spoken programming. In addition, I describe a supporting editor that improvesrecognition accuracy by making use of type information and scoping to increase recognizer context.

Model update is a formal approach to correct a system model M w.r.t some property not satisfied by M. In this work, we show how this formal approach can be used for plan and planning domain verification and update. While a model checking method can directly be used to perform plan verification, model update techniques can be used to either update an incorrect plan and\or update a planning domain specification. Well known model update approaches are based on CTL — a logic which does not take into account the actions. In previous work, we have proposed the alpha-CTL logic, a logic whose semantics is based on actions. Here, we are proposing a model update system based on alpha-CTL which is able to automatically modify a plan M, generating a new plan M' that satisfies phi or, if there is not such a plan, to automatically update the corresponding planning domain.

The major contributions of this work include a set of biographical mann 2002), ethnicity recognition (Lu and Jain 2004), eyeglasses feature extractors brought together by a probabilistic identification (Jiang, Binkert, and Achermann 2000), graphical model. Most of this work is limited and addressed to a particular resulting in a text descriptor to describe triage images of disaster set of images and tends to do poorly with disaster victims. The model is built using domain information victim images. At the same time, there is no particular work gathered from data and literature. Our goal is to automatically Feature extraction as introduced above needs to be preceded process images of patients taken as part of the intake by first locating the person in the image, particularly the process at emergency medical care centers to extract searchable, face.

Intelligent tutoring systems (ITSs) provide students with a one-on-one tutor, allowing them to work at their own pace, and helping them to focus on their weaker areas. The RUR1–Python Learning Environment (RUR-PLE), a game-like virtual environment to help students learn to program, provides an interface for students to write their own Python code and visualize the code execution (Roberge 2005). RUR-PLE provides a fixed sequence of learning lessons for students to explore. We are extending RUR-PLE to develop the Playing to Program (PtP) ITS, which consists of three components: (1) a Bayesian student model that tracks student competence, (2) a diagnosis module that provides tailored feedback to students, and (3) a problem selection module that guides the student’s learning process. In this paper, we summarize RUR-PLE and the PtP design, and describe an ongoing user study to evaluate the predictive accuracy of our student modeling approach.

Researchers have established the value of hands-on learning with tangible artifacts in mathematics and related fields. Inspired by this work, an assignment was developed for an undergraduate/graduate Artificial Intelligence course to introduce students to the formal representation of search. Students analyzed a familiar board game — e.g., Rush Hour or peg solitaire — using the standard approach to modeling an uninformed search process. The assignment was well-received by students, and analysis of their work yielded unexpected insights into the challenges students face in understanding how the formal problem model interacts with search algorithms. This paper introduces the theoretical motivations for the work, analyzes student work products, and makes recommendations for future extensions.

Most real-world negotiation involves multiple interdependent issues, which makes an agent's utility functions complex. Traditional negotiation mechanisms, which were designed for linear utilities, do not fare well in nonlinear contexts. One of the main challenges in developing effective nonlinear negotiation protocols is scalability; it can be extremely difficult to find high-quality solutions when there are many issues, due to computational intractability. One reasonable approach to reducing computational cost, while maintaining good quality outcomes, is to decompose the contract space into several largely independent sub-spaces. In this paper, we propose a method for decomposing a contract space into sub-spaces based on the agent's utility functions. A mediator finds sub-contracts in each sub-space based on votes from the agents, and combines the sub-contracts to produce the final agreement. We demonstrate, experimentally, that our protocol allows high-optimality outcomes with greater scalability than previous efforts. We also address incentive compatibility issues. Any voting scheme introduces the potential for strategic non-truthful voting by the agents, and our method is no exception. For example, one of the agents may always vote truthfully, while the other exaggerates so that its votes are always "strong." It has been shown that this biases the negotiation outcomes to favor the exaggerator, at the cost of reduced social welfare. We employ the limitation of strong votes to the method of decomposing the contract space into several largely independent sub-spaces. We investigate whether and how this approach can be applied to the method of decomposing a contract space.

Recognizing possibly thousands of objects is a crucial capability for an autonomous agent to understand and interact with everyday environments. Practical object recognition comes in multiple forms: Is this a coffee mug (category recognition). Is this Alice's coffee mug? (instance recognition). Is the mug with the handle facing left or right? (pose recognition). We present a scalable framework, Object-Pose Tree, which efficiently organizes data into a semantically structured tree. The tree structure enables both scalable training and testing, allowing us to solve recognition over thousands of object poses in near real-time. Moreover, by simultaneously optimizing all three tasks, our approach outperforms standard nearest neighbor and 1-vs-all classifications, with large improvements on pose recognition. We evaluate the proposed technique on a dataset of 300 household objects collected using a Kinect-style 3D camera. Experiments demonstrate that our system achieves robust and efficient object category, instance, and pose recognition on challenging everyday objects.

We describe a robot system that autonomously acquires skills through interaction with its environment. The robot learns to sequence the execution of a set of innate controllers to solve a task, extracts and retains components of that solution as portable skills, and then transfers those skills to reduce the time required to learn to solve a second task.

In many real world applications, the number of examples to learn from is plentiful, but we can only obtain limited information on each individual example. We study the possibilities of efficient, provably correct, large-scale learning in such settings. The main theme we would like to establish is that large amounts of examples can compensate for the lack of full information on each individual example. The type of partial information we consider can be due to inherent noise or from constraints on the type of interaction with the data source. In particular, we describe and analyze algorithms for budgeted learning, in which the learner can only view a few attributes of each training example, and algorithms for learning kernel-based predictors, when individual examples are corrupted by random noise.

Ontology-based data access is a powerful form of extending database technology, where a classical extensional database (EDB) is enhanced by an ontology that generates new intensional knowledge which may contribute to answer a query. Recently, the Datalog+/- family of ontology languages was introduced; in Datalog+/-, rules are tuple-generating dependencies (TGDs), i.e., Datalog rules with the possibility of having existentially-quantified variables in the head. In this paper we introduce a novel Datalog+/- language, namely sticky sets of TGDs, which allows for a wide class of joins in the body, while enjoying at the same time a low query-answering complexity. We establish complexity results for answering conjunctive queries under sticky sets of TGDs, showing, in particular, that ontological conjunctive queries can be compiled into first-order and thus SQL queries over the given EDB instance. We also show some extensions of sticky sets of TGDs, and how functional dependencies and so-called negative constraints can be added to a sticky set of TGDs without increasing the complexity of query answering. Our language thus properly generalizes both classical database constraints and most widespread tractable description logics.