rlworkgroup / akro Goto Github PK

This is a common use case which leads to a lot of unnecessary munging.

e.g.

    def observation_space(self):
        task_ub, task_lb = self.task_space.bounds
        env_ub, env_lb = super(OneHotMultiTaskEnv,
                               self).observation_space.bounds
        return spaces.Box(
            np.concatenate([task_ub, env_ub]),
            np.concatenate([task_lb, env_lb]))

Could just be

    def observation_space(self):
        task = self.task_space
        obs = super(OneHotMultiTaskEnv,
                               self).observation_space
        return spaces.Box.concatenate(task, obs)

This will require some thought about how non-alike spaces interact, and should provide a feature for concatenating members of these spaces easily and consistent with this spec, once a space is described as a concatenation of other spaces.

Imported from ryanjulian/rllab#2

See https://travis-ci.com/rlworkgroup/akro/jobs/199317054#L472 for an example log.

This library would be more effective if it were phrased as an extension for gym.Spaces, i.e. akro types can be used as drop-in replacement types for gym.Spaces types, but with extra features.

This can probably be achieved by inheriting from spaces types and running the gym test suite on akro types in the CI

I want to use discrete action space via akro.Discrete, but what I get in my step function is not discrete numbers, but a list of float numbers. But akro.Box does work well. So can someone tell me what is the problem?

Currently, all of the spaces assume that the datatype is np.float32. However, some environments use e.g. np.uint8. We should support that.

See garage PR 455.

All methods currently raising a NotImplementedError should be completed within dict.py.

Hi, I am facing an issue where I get an "illegal hardware instruction" error when trying to run import akro. I'm using a M1 mac. Could this be the issue? How might you suggest I could fix it? Thank you!

This would add tagged data types (and no-copy constructors) for the concrete types represented by a spaces.

This would allow users to perform important akro operations without needing an explicit reference to the space (and saves a lot of type checking). It would also get rid of a lot of helper/misc functions.

This idea is best illustrated by an example:

import akro

dspace = akro.Dict({'foo': akro.Discrete(3)})

d = {'foo': 1}  # a regular old dict
d_tagged = akro.tag(d, dspace)  # returns an akro.dict (inherits from dict) which stores dspace
d_flat = d_tagged.flatten()  # now I can flatten without any args
d_flat.to_tf_placeholder()  # sure, why not?
e = dspace.sample()  # returns an akro.dict by default)