|
High-level Language Compilers/Interpreters for Cognitive Models
Navy SBIR 2009.1 - Topic N091-086 ONR - Mrs. Tracy Frost - [email protected] Opens: December 8, 2008 - Closes: January 14, 2009 N091-086 TITLE: High-level Language Compilers/Interpreters for Cognitive Models TECHNOLOGY AREAS: Information Systems, Human Systems ACQUISITION PROGRAM: PMA 205: Naval Aviation Simulation Master Plan Program of Record The technology within this topic is restricted under the International Traffic in Arms Regulation (ITAR), which controls the export and import of defense-related material and services. Offerors must disclose any proposed use of foreign nationals, their country of origin, and what tasks each would accomplish in the statement of work in accordance with section 3.5.b.(7) of the solicitation. OBJECTIVE: Representations and compilers/interpreters capable of increasing the efficiency of cognitive model development for multiple cognitive architectures. DESCRIPTION: Advanced human-behavior-modeling software is becoming increasingly needed to improve the automation, efficiency, and overall capability of US forces. Such software can mimic human decision-making, reasoning, learning and, in many cases, cultural and social biases, as well as perceptual, motor, and cognitive limitations. Cognitive architectures provide powerful, proven computational platforms for this type of software, including core computational abstractions and processes such as goal management, working memory, pattern matching, inference, long-term memory and learning. However, models developed within these architectures must currently be programmed at a fine-grained level roughly equivalent to assembly languages in software systems. This makes building intelligent models for these architectures time consuming and costly, requiring experts in the details of cognitive architectures. The process is also error prone, and the resulting models are difficult to maintain, combine, and expand. Traditional software development has benefited from the development of increasingly abstract high-level languages, which make software programs for traditional computer systems orders of magnitude faster to build. A key aspect of that methodology is to exploit these abstractions in order to trade minor performance optimizations in favor of the ability to build increasingly complex systems by combining previously developed pieces of functionality. Similar advancements are required in human-behavior model development to increase the cost efficiency of model development and to increase the range of developers that can build such models. Even more fundamentally, an important goal is to raise by orders of magnitude the complexity ceiling of human-behavior models and the tasks that they can perform. Research efforts to define high-level languages for cognitive architectures have shown [1,2,3] that high-level languages can be defined and applied successfully to reduce the time to develop cognitive models. However, research to this point has focused on small-scale problems and narrow domains. What is needed are more complete representations and compilation solutions that include the following: (1) support for multiple target cognitive architectures, (2) robust compilation algorithms capable of processing arbitrary cognitive models at a high-level of specification and generating robust execution code, (3) sufficient tool support that includes editors and debuggers that operate on the high-level representation rather than the architecture-specific representation. There are a number of challenging issues associated with such an effort and a number of dimensions along which a representation and compiler must succeed. First, to increase developer efficiency, a representation must abstract the details of model development while simultaneously retaining the power that cognitive architectures provide. Second, the representation must be complete, allowing it to be useful as a general-purpose language without requiring development across multiple layers of abstraction. Third, the language and its tools must be transparent, allowing behavior to be understandable and debuggable. Fourth, the compiler/interpreter must produce models that execute efficiently. Finally, the representation must be scalable and allow for incrementally building large models through components or modules. Successful efforts will balance these conflicting requirements while paying special attention to key requirements, such as time to implement and maintain a model, as well as scalability of resulting models. Efforts should seek to push the state of the art in this area and should specifically seek to provide a robust, useable solution by the end of phase II. PHASE I: Design a high-level modeling language that encapsulates a useful set of language primitives, and instantiate them in at least two cognitive architectures sufficient for a capability demonstration. The design should be an abstraction (or a "higher level") over the cognitive architecture�s native representation and should not require any development using the cognitive architecture�s primitives. Furthermore, the aspects of the architecture that have been abstracted, and the tradeoffs that have been evaluated, should be explicitly called out in the design. Conversely, the specification should detail which aspects of the architecture are directly exploited and to what extent. The language design should also contain requirements for implementing debuggers and integrated development environments (IDEs) for the language. Design efforts in Phase I should also demonstrate or provide arguments to show how the language could usefully target additional architectures and address the issues involved in supporting multiple architectures. Finally, Phase I should include the development of a plan for implementing, evaluating, and deploying the new language. PHASE II: Implement a compiler or interpreter for the language designed in Phase I, with the ability to process arbitrary models defined in the language and generate code that can execute within at least two cognitive architectures. Design and implement a development environment, including support for high-level code generation, as well as a debugger that functions at the abstract language level, allowing developers to debug their models in the same representation in which they construct them. Evaluate and demonstrate the language and compiler on example applications, including cognitive models of complex, interactive tasks. Develop and apply metrics comparing the code generation process as well as the resulting models between the native architectures and the high-level language. Demonstrate which mechanisms of the target architectures are being exploited and to what extent. Demonstrate the process by which the high-level language can be used to author and maintain increasingly complex cognitive models. Refine and complete the language design. PHASE III: Rigorously evaluate the language and compiler. Resolve language and compiler issues. Transition the language evaluation and application to cognitive modeling and intelligent agent systems. Develop documentation and a tutorial. Complete implementation of the debugger or an integrated development environment, and deploy into an environment where it is used to create models for applications and/or research. PRIVATE SECTOR COMMERCIAL POTENTIAL/DUAL-USE APPLICATIONS: Decades of the development of the field of software engineering have demonstrated the cost advantages of creating increasingly high-level languages and tools for building software systems. Now, the commercial market is seeing higher demand for software that can capture human decision-making processes. These potential applications include customer-service interaction systems, "serious games" for training, expert decision-support systems for medical and business critical decision making, and information and services management systems such as web- and phone-based travel services. The state of the art in human behavior modeling has demonstrated the technical feasibility of developing these systems, but they remain expensive largely because there are not yet cost-effective higher levels of abstraction. The development of high-level languages for human behavior modeling will decrease the entry costs for developing these systems. REFERENCES: 2. Cohen, M. A., Ritter, F. E., & Haynes, S. R. (2005). Herbal: A high-level language and development environment for developing cognitive models in Soar. In Proceedings of the 14th Conference on Behavior Representation in Modeling and Simulation. 177-182. 05-BRIMS-044. Orlando, FL: U. of Central Florida KEYWORDS: Cognitive Architectures; Programming Languages; Knowledge Representation; Human Behavior Models; High-level Computer languages; Affordability
|