Dat7: Adaptive Utility Learning

In this project a method is developed that can learn the preferences of an observed agent. These preferences are assumed to be expressed as utility values in a know influence diagram. The utilities are learned by creating constraints over the possible utility values, based on what is observed. A fundamental assumption is the decision maker that is being observed is acting rational. i.e. he always makes decisions so that he gets the maximum expected utility. So when a decision is observed it can be deduced that the expected utility of that decision is higher than the alternatives. This is the core of how the constraints over the utility values are created.

The observations may be found by passively observing the decision maker. This is how they are obtained for Utility Iteration from "Learning utility Functions by Imputing". However, in this project the observations are not randomly generated but rather selected carefully. Also the method in this project allows prior knowledge to used to improve the accuracy of the method. The method is based on Utility Iteration from "Learning utility Functions by Imputing". The method is tested through a couple of experiments and compared with the results of Utility Iteration. The results indicates that a higher accuracy can be achieved through fewer observations.

Dat6: Learning Utility Functions by Imputing

In this project two methods, called Utility Iteration and Imputing by Comparison, are developed. These methods learn the utilities of an observed agent, such that its preferences can be modeled in an influence diagram. The utilities are learned from the behavior of the agent, by creating constraints based on the observed decisions made by it. The two methods are designed to handle agents that change behavior, using different policies to handle conflicting behavior. The methods have much in common with FLUF, the main difference being how partially observed strategies are handled. Where FLUF relaxes constraints to ensure that the true utility function is not excluded, then Utility Iteration and Imputing by Comparison impute observations to make the strategy fully observed, thereby removing the need to relax constraints. Experiments are conducted with the two new methods and with FLUF. Three different kinds of changing behavior are defined, and experiments are conducted with respect to each kind. Both in the experiments with changing behavior and the experiment with static behavior, the new methods achieved better results than FLUF, both with regard to accuracy and learning speed. It is concluded that, under the assumption made about the domain in this project, imputing observations will yield a higher accuracy than relaxing constraints.

Dat5: FLUF Learning Utility Function

In this project a method, named FLUF, for learning the utilities in an influence diagram is developed. The main idea behind this approach is that learning an agents utilities should give a good estimate of the agents strategy quickly. How this is handled is mainly derived from the work done by cite{Koller}. They work on decision trees whereas FLUF works on influence diagrams. Another difference is that FLUF is able to handle agents that change behavior by using two different policies. A simple form of fractional updating, called frequency counting, is used for comparison. To evaluate FLUF a series of experiments have been performed. These experiments have shown that FLUF, no matter constraint removing policy, fairly quickly reaches a reasonable performance level. In particular, FLUF estimates which decisions that would yield a high expected utility to its human counterpart. All in all FLUF is able to predict the decisions of a player given various domains. FLUF also shows a fast convergence toward the correct maximum expected utility. Given enough observations frequency counting performs equally as well, so if speed is prioritized then FLUF should be the method of choice.

F8S: An XML to Java Binding

This article deals with the binding of XML documents to the Java programming language. In particular we investigate problems related to type checking at compile time. This is done by constructing a language that can bind XML data to Java objects by using modified XQuery constructs to extract the XML data. Also the grammar for these modified constructs will be presented and discussed. Furthermore a constraint for the language is that neither the XML document''s format nor the data representation in Java can be altered by the user of our language. Strategies for how a compiler addresses type checking problems will be suggested. To perform the type checking at compile time we will introduce a type tree which will make it easier to perform type checking. Unfortunately it is not always possible to make a complete type check at compile time. In certain situations it is only possible to give a warning as it is impossible to determine types prior to runtime. To describe these situations the concept of partial type checking is introduced.

F7S/BOS: 3D Rendering with Animation and Collision Detection

This report focuses on some of the topics involved in creating a 3D rendering engine. Specifically it focuses on general rendering of 3D scenes, animation and collision detection. The report will present the theory behind these topics and this theory will then be put into use by implementing a simple 3D engine. This engine will make use of the graphics from the game Neverwinter Nights developed by Bioware. The resulting product will have the capability to load an environment from the game and let a user freely navigate an animated character from the game through the environment with collision detection. Keywords for this project includes: linear algebra for 3D graphics, animation using linear interpolation and Bezier interpolation, texture mapping and filtering, lights and shading, scene graphs.

F6S: Real-Time Java Virtual Machine

This report will focus on the task of extending an existing Java Virtual Machine with real-time c apabilities, in adherence to the Real-Time Specifications for Java (RTSJ), provided by The Real-Time for Java Expert Group. Topics like selecting an appropriate underlying operating system will be discussed, and parts of the RTSJ will be presented and evaluated. In the last part of the report the parts of the RTSJ that were chosen to be implemented will be described. The primary focus of the specification in this report has been the part regarding scheduling, and to a lesser extend memory management.