Welcome to CoopIHC’s documentation!

Warning

This is a version that is not entirely completed. Documentation may be outdated in some places. Please contact me directly or raise an issue if appropriate.

CoopIHC (pronounced “kopik”) is a Python module that provides a common basis for describing computational Human Computer Interaction (HCI) contexts, mostly targeted at expressing models of users and intelligent assistants.

1. It provides a common conceptual and practical reference, which facilitates reusing and helps extending other researcher’s work. Some examples that use CoopIHC can be found in the CoopIHC-Zoo. These full examples, or parts thereof, can be re-used easily by a CoopIHC end-user.

2. It can help design intelligent assistants. For example, you can wrap a CoopIHC Bundle into an environment that is compatible with gym and use off-the-shelf Deep Reinforcement Learning algorithms to train a policy for an intelligent assistant.

3. It provides modeling help. Currently, some checks are provided to ensure model paramters are correctly identifiable, see CoopIHC-ModelChekcs

The philosophy of CoopIHC is to separate interactive systems into three components:

1. A task,

2. A user, which is either a real user or a synthetic user model,

3. An assistant agent which helps the user accomplish its task.

and bundling them back together using a so-called Bundle. Bundles can be used for many different cases:

• Evaluate user (synthetic or real) coupled with an intelligent assistant,

• Train a user model to obtain a realistic synthetic user model,

• Train an intelligent assistant given some synthetic user model,

• Jointly train an intelligent assistant and a synthetic user model …

• … and more

CoopIHC builds on a two-agent interaction model, see the Interaction Model and Terminology.

Tutorial

• Quick Start
• More Complex Example
• Modularity
• Using Reinforcement Learning
• Interfacing CoopIHC with a real user
• Assistants that simulate users

User Guide

• The Interaction Model
• Space
• StateElement
• State
• Tasks
• Agents
• Policies
• The Observation Engines
• The Inference Engines
• Bundles
• Random Number Generators
• Rendering
• Parameters
• High-Level objects
• User Modeling Facilitation
• Wrappers
• Task and Agent Repository

See also

• Home page
• Terminology

Known Caveats

1. The mechanism for implementing parameters can lead to a stack overflow: if you try to access an attribute of a CoopIHC class without having run the super class’s __init__(), then you will likely get a stack overflow instead of an AttributeError. Either call the super class’s __init__(), or set self._bundle = None and self.parameters = {} in the object’s init.

I think these are fixed:

1. In place additions e.g. self.state['x'] += 1 work, but do not trigger the expected out_of_bounds_mode behavior. in short, the reason for that is that in place addition calls __iadd__ which is not a Numpy __ufunc__. There are several workarounds possible. One based on the @implements mechanism described in the StateElement page which would fix the problem for everyone. Another is simply to do something like self.state['x'] = self.state['x'] + 1

2. Some forms of indexing do not work e.g. self.state['x'][:,1] = [2,3] does not work. The problem could be overcome if someone shows interest. In practical cases you can work around this limitation.

Indices

• Index

• Module Index

• Search Page