mujoco-worldgen - GitLite

KO | EN

gitlite — search

#python #hacktoberfest #ai #android #rust #linux #macos #nodejs #awesome #cli #kubernetes #pytorch #security #openai

mujoco-worldgen

(★ 589)

Automatic object XML generation for Mujoco

파일 탐색기

최종 버전 다운로드 (.zip)

- - ramp.stl
- - smiley.png
- examine.py
- make_shape.py
- example_env_examine.jsonnet
- particle_gather.py
- simple_particle.py
- - __init__.py
  - floor.py
  - geom.py
  - material.py
  - obj.py
  - obj_from_stl.py
  - obj_from_xml.py
- - __init__.py
  - const.py
  - normalize.py
  - parser.py
- - __init__.py
  - geometry.py
  - obj_util.py
  - parse_arguments.py
  - path.py
  - placement.py
  - rotation.py
  - sim_funcs.py
  - types.py
- __init__.py
- builder.py
- core.py
- env.py
- transforms.py
.gitignore
LICENSE
README.md
requirements.txt
setup.py

🚀 설치 가이드

1. 코드 내려받기

git clone https://github.com/openai/mujoco-worldgen

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd mujoco-worldgen

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Python

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Python 3 설치 시 'Add Python to PATH' 옵션을 꼭 체크하세요 (Windows).

pip install -r requirements.txt

requirements.txt 등에 명시된 파이썬 라이브러리를 설치합니다.

pip install -e .

requirements.txt 등에 명시된 파이썬 라이브러리를 설치합니다.

✅ 에러 메시지 없이 실행되고 터미널에 안내 문구가 출력되면 정상입니다.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

**Status:** Archive (code is provided as-is, no updates expected)

# Worldgen: Randomized MuJoCo environments

Worldgen allows users to generate complex, heavily randomized environments environments. Examples of such environments can be found in the `examples` folder.

Actions in `action_space` are all actuators of objects added during world building. Not all objects will have actuators, but some do (e.g. `ObjFromXML('particle')` and `ObjFromXML('particle_hinge')`). You can examine the meaning of a given action by looking at the xml file of the object in `assets/xmls/.../main.xml`

Observation spaces are inferred based on the outputs of the `get_obs` function in an `Env` object (`Env` class is defined in `mujoco_worldgen/env.py`.

## Installation

This repository requires the MuJoCo physics engine (the repository has been tested with MuJoCo 1.50). To install MuJoCo, follow the instructions in the [mujoco-py](https://github.com/openai/mujoco-py/tree/1.50.1.0) repository.

```
    pip install -r requirements.txt
    pip install -e .
```

This repository has been used on Mac OS X and Ubuntu 16.04 with Python 3.6

## Walkthrough

### Initial steps

Let’s analyze an example of one such generation.  First we create the `WorldParams`:

```
    world_params = WorldParams(size=(5, 5, 3.5))
```

This defines the global properties of our generated world.
Metric units used in worldgen are meters, kilograms, and angles are given in radians: `[-pi, pi]`. 
The following are all optional paramaters with defaults:

-  `size`: The size of the space available for placing objects. (Default: `(10., 10., 2.5)`)
-  `num_substeps`: The number of physics substeps to perform within every call to `step()`. (Default: `1`)
-  `randomize_light`: Whether to randomize the lighting conditions. (Default: `False`)
-  `randomize_material`: Whether to randomize the materials that are applied to objects. (Default: `False`)
-  `placement_margin`: The minimum distance between placed objects. (Default: `0.0`)
-  `show_outer_bounds`: Whether to visualize the outer bounds. (Default: `False`)

Then, we create a builder. The `WorldBuilder` constructor takes a `WorldParams` object and `seed`, which is used for randomization:

```
	builder = WorldBuilder(world_params, seed)
```

### Placing objects

Here's an example of adding geometries to our world:

```
    # Create a floor
    floor = Floor()

# Load geometries from XML, and add to floor
    robot = ObjFromXML("particle")
    floor.append(robot)
    sphere = ObjFromXML("sphere")
    floor.append(sphere)

# Create a primitive geometry, and add to floor
    box = Geom('box')
    floor.append(box)

# Add the root floor to the builder
    builder.append(floor)
```

The `append()` function allows to specify a placement indicator (Usually “top” or “inside”).
Placements are spaces we’re able to place objects. 
Placements are always world-aligned rectangular prisms, which objects can be oriented within.  All objects within a placement align along the bottom (and are positioned with X,Y coordinates).
If there are multiple placements for a given name (e.g. “inside\_0”, “inside\_1”, …) then we choose one at random.
The default placement name is “top”.

To customize the placement position:

```
    obj.append(child_obj, placement_name="top", placement_xy=None)
```

`placement_xy` is None if you want the world generation algorithm to randomly place it.
Otherwise it is an X, Y pair where both are within `[0.0, 1.0]`.
The object will be placed within the bounds, scaled by its size.
*Note:* this is because the size of the placement (e.g. table) might not
be known until generation time. To add some more objects:

```
    obj.append(child_obj, 'top', (0.5, 1))  # placed in the center of the back
    obj.append(child_obj, 'top', (0.5, 0.5))  # placed in the center
    obj.append(child_obj, 'top', (0, 0))  # placed in the lower left corner
```

### Geoms

There are several kinds of primitive geoms: “box”, “sphere”, “cylinder”.
We can specify the size of a geom by providing a second parameter: `Geom("box", (0.1, 0.2, 0.3))` which would result in box of size 10cm x 20cm x 30cm.
For a cube: `Geom("box", 0.25)` results in “box” of size 25cm x 25cm x 25cm.
Moreover, we can provide a range to sample a random size box: `Geom("box", (0.1, 0.2, 0.3), (1.1, 1.2, 1.3))`.
Size of this box would be random between 10cm x 20cm x 30cm and 1.1m x 1.2m x 1.3m.

### Sites
You can create sites - static markers on an object - by calling `obj.mark()`. The current position of all created sites is stored in the `sim` object of the worldgen environment. For more information on sites, check out the `mark` function in the `Obj` class defined in `mujoco_worldgen/objs/obj.py`

Example usage:
```
# Create a floor and a box
floor = Floor()
box = Geom('box')

# Mark sites on floor and box
floor.mark(mark_name='floor_site', relative_xyz=(0.2, 0.2, 0))
box.mark(mark_name='box_site', relative_xyz=(0, 0, 0.5))

# Add box to floor, add the floor to the builder, and create a sim with the builder
floor.append(box)
builder.append(floor)
sim = builder.get_sim()

# Get the current position of the floor site and the box site
floor_site_pos = sim.data.site_xpos[sim.model.site_name2id('floor_site')]
box_site_pos = sim.data.site_xpos[sim.model.site_name2id('box_site')]
```

### Environments

You can create new environments with Worldgen by subclassing the `Env` class and defining the following methods:

- `_get_sim`
- `_get_obs`
- `_get_reward` : You can also use a reward wrapper instead of defining this.

You can see two examples in the `examples` folder - the `simple_particle` environment and the `particle_gather` environment.
You can test out environments using the `/bin/examine` script, providing either a python script defining the `make_env` or a jsonnet file.

```
    ./bin/examine.py examples/simple_particle.py
```

```
    ./bin/examine.py examples/example_env_examine.jsonnet
```

## Acknowledgements

Credits to Alex Ray for writing the original version of Worldgen that OpenAI was using internally - the majority of the code in this repository has been copied over from the original Worldgen with minor changes.