def map_input(transfer_env, i_value, added_constant, gnn_option_list):
assert len(gnn_option_list) == 4
ienv, oenv = [env + '-v1' for env in transfer_env.split('2')]
ienv_info = mujoco_parser.parse_mujoco_graph(
ienv,
gnn_node_option=gnn_option_list[0],
root_connection_option=gnn_option_list[1],
gnn_output_option=gnn_option_list[2],
gnn_embedding_option=gnn_option_list[3])
oenv_info = mujoco_parser.parse_mujoco_graph(
oenv,
gnn_node_option=gnn_option_list[0],
root_connection_option=gnn_option_list[1],
gnn_output_option=gnn_option_list[2],
gnn_embedding_option=gnn_option_list[3])
o_value = np.zeros([oenv_info['debug_info']['ob_size'], i_value.shape[1]])
assert len(i_value) == ienv_info['debug_info']['ob_size']
ienv_node_name_list = [node['name'] for node in ienv_info['tree']]
for output_id, output_node_id in oenv_info['input_dict'].iteritems():
# get the name of the joint
node_name = oenv_info['tree'][output_id]['name']
# if the node is alreay in the input environment?
if node_name in ienv_node_name_list:
o_value[output_node_id] = i_value[ienv_info['input_dict'][
ienv_node_name_list.index(node_name)]]
else:
continue
return o_value
def map_output(transfer_env, i_value, added_constant, gnn_option_list):
'''
@brief:
i_value could be the logstd (1, num_action), policy_output/w
(64, num_action), policy_output/b (1, num_action)
'''
assert len(gnn_option_list) == 4
i_value = np.transpose(i_value) # make the num_action to the front
ienv, oenv = [env + '-v1' for env in transfer_env.split('2')]
ienv_info = mujoco_parser.parse_mujoco_graph(
ienv,
gnn_node_option=gnn_option_list[0],
root_connection_option=gnn_option_list[1],
gnn_output_option=gnn_option_list[2],
gnn_embedding_option=gnn_option_list[3])
oenv_info = mujoco_parser.parse_mujoco_graph(
oenv,
gnn_node_option=gnn_option_list[0],
root_connection_option=gnn_option_list[1],
gnn_output_option=gnn_option_list[2],
gnn_embedding_option=gnn_option_list[3])
if len(i_value.shape) > 1:
o_value = np.zeros([len(oenv_info['output_list']), i_value.shape[1]])
else:
# the b matrix
o_value = np.zeros([len(oenv_info['output_list'])])
assert len(i_value) == len(ienv_info['output_list'])
ienv_node_name_list = [node['name'] for node in ienv_info['tree']]
for output_id, output_node_id in enumerate(oenv_info['output_list']):
# get the name of the joint
node_name = oenv_info['tree'][output_node_id]['name']
# if the node is alreay in the input environment?
if node_name in ienv_node_name_list:
if ienv_node_name_list.index(node_name) not in \
ienv_info['output_list']:
logger.warning('Missing joint: {}'.format(node_name))
continue
o_value[output_id] = i_value[ienv_info['output_list'].index(
ienv_node_name_list.index(node_name))]
else:
# the name format: "@type_@name_@number", e.g.: joint_leg_1
assert len(node_name.split('_')) == 3
# find all the repetitive node and calculate the average
repetitive_struct_node_list = [
ienv_node_name_list.index(name) for name in ienv_node_name_list
if node_name.split('_')[1] == name.split('_')[1]
]
num_reptitive_nodes = float(len(repetitive_struct_node_list))
assert len(repetitive_struct_node_list) >= 1
for i_node_id in repetitive_struct_node_list:
o_value[output_id] += i_value[ienv_info['output_list'].index(
i_node_id)] / num_reptitive_nodes
return np.transpose(o_value) + added_constant
from graph_util.mujoco_parser import parse_mujoco_graph
from graph_util.graph_operator import GraphOperator
from scripts.dgl_samples.gcn import GCN
from collections import deque
import torch as th
import torch.nn as nn
import torch.nn.functional as F
import gym
env_name = "WalkersHopperthree-v1"
env = gym.make(env_name)
node_info = parse_mujoco_graph(task_name=env_name)
graph_operator = GraphOperator(input_dict=node_info["input_dict"],
output_list=node_info["output_list"],
obs_shape=env.observation_space.shape[0])
graph_operator.get_all_attributes()
g = graph_operator._create_graph()
nx_G = g.to_networkx()
# nx.draw(nx_G)
# plt.show()
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.gcn1 = GCN(1, 16, F.relu)
self.gcn2 = GCN(16, 1, F.relu)
def _parse_mujoco_template(self):
'''
@brief:
In this function, we construct the dict for node information.
The structure is _node_info
@attribute:
1. general informatin about the graph
@self._node_info['tree']
@self._node_info['debug_info']
@self._node_info['relation_matrix']
2. information about input output
@self._node_info['input_dict']:
self._node_info['input_dict'][id_of_node] is a list of
ob positions
@self._node_info['output_list']
3. information about the node
@self._node_info['node_type_dict']:
self._node_info['node_type_dict']['body'] is a list of
node id
@self._node_info['num_nodes']
4. information about the edge
@self._node_info['edge_type_list'] = self._edge_type_list
the list of edge ids
@self._node_info['num_edges']
@self._node_info['num_edge_type']
6. information about the index
@self._node_info['node_in_graph_list']
The order of nodes if placed by types ('joint', 'body')
@self._node_info['inverse_node_list']
The inverse of 'node_in_graph_list'
@self._node_info['receive_idx'] = receive_idx
@self._node_info['receive_idx_raw'] = receive_idx_raw
@self._node_info['send_idx'] = send_idx
7. information about the embedding size and ob size
@self._node_info['para_size_dict']
@self._node_info['ob_size_dict']
self._node_info['ob_size_dict']['root'] = 10
self._node_info['ob_size_dict']['joint'] = 6
'''
# step 0: parse the mujoco xml
if 'evo' in self.args.task:
self._node_info = gen_gnn_param.gen_gnn_param(
self._task_name,
self.adj_matrix,
self.node_attr,
gnn_node_option=self._gnn_node_option,
root_connection_option=self._root_connection_option,
gnn_output_option=self._gnn_output_option,
gnn_embedding_option=self._gnn_embedding_option)
else:
self._node_info = mujoco_parser.parse_mujoco_graph(
self._task_name,
gnn_node_option=self._gnn_node_option,
root_connection_option=self._root_connection_option,
gnn_output_option=self._gnn_output_option,
gnn_embedding_option=self._gnn_embedding_option)
# step 1: check that the input and output size is matched
gnn_util.io_size_check(self._input_size, self._output_size,
self._node_info, self._is_baseline)
# step 2: check for ob size for each node type, construct the node dict
self._node_info = gnn_util.construct_ob_size_dict(
self._node_info, self._input_feat_dim)
# step 3: get the inverse node offsets (used to construct gather idx)
self._node_info = gnn_util.get_inverse_type_offset(
self._node_info, 'node')
# step 4: get the inverse node offsets (used to gather output idx)
self._node_info = gnn_util.get_inverse_type_offset(
self._node_info, 'output')
# step 5: register existing edge and get the receive and send index
self._node_info = gnn_util.get_receive_send_idx(self._node_info)
from graph_util.mujoco_parser import parse_mujoco_graph
from graph_util.graph_operator import GraphOperator
import networkx as nx
import matplotlib.pyplot as plt
node_info = parse_mujoco_graph(task_name="WalkersHopperone-v1")
graph_operator = GraphOperator(input_dict=node_info["input_dict"],
output_list=node_info["output_list"],
obs_shape=11)
graph_operator.get_all_attributes()
g = graph_operator._create_graph()
nx_G = g.to_networkx()
nx.draw(nx_G)
plt.show()
def call(self, inputs):
hidden = inputs
for i in range(self.num_layers):
hidden = getattr(self, "layer_{}".format(i))(hidden)
return hidden
def __str__(self):
return self._summary
eager_setup()
args = get_config()
input_feat_dim = args.gnn_input_feat_dim
node_info = parse_mujoco_graph(task_name=args.task)
env = gym.make(args.task)
action_shape = env.action_space.shape[0]
"""
=== Build the node info by reading the XML
"""
# step 0-1: check for ob size for each node type, construct the node dict
node_info = gnn_util.construct_ob_size_dict(node_info, input_feat_dim)
# step 0-2: get the inverse node offsets (used to construct gather idx)
node_info = gnn_util.get_inverse_type_offset(node_info, 'node')
# step 0-3: get the inverse node offsets (used to gather output idx)
node_info = gnn_util.get_inverse_type_offset(node_info, 'output')
def map_transfer_env_running_mean(ienv, oenv, running_mean_info,
observation_size, gnn_node_option,
root_connection_option, gnn_output_option,
gnn_embedding_option):
# parse the mujoco information
ienv_info = mujoco_parser.parse_mujoco_graph(
ienv,
gnn_node_option=gnn_node_option,
root_connection_option=root_connection_option,
gnn_output_option=gnn_output_option,
gnn_embedding_option=gnn_embedding_option)
oenv_info = mujoco_parser.parse_mujoco_graph(
oenv,
gnn_node_option=gnn_node_option,
root_connection_option=root_connection_option,
gnn_output_option=gnn_output_option,
gnn_embedding_option=gnn_embedding_option)
i_running_mean_info = running_mean_info
# we start the running mean by cutting the mean to 0.1
start_coeff = 1
o_running_mean_info = {
'step': i_running_mean_info['step'] * start_coeff,
'mean': np.zeros([observation_size]),
'variance': np.zeros([observation_size]),
'square_sum': np.zeros([observation_size]),
'sum': np.zeros([observation_size])
}
ienv_node_name_list = [node['name'] for node in ienv_info['tree']]
for node, oenv_digit in oenv_info['input_dict'].items():
node_name = oenv_info['tree'][node]['name']
# if the node is alreay in the input environment?
if node_name in ienv_node_name_list:
ienv_digit = ienv_info['input_dict'][ienv_node_name_list.index(
node_name)]
assert len(ienv_digit) == len(oenv_digit)
# assign the value!
for key in ['square_sum', 'sum']:
o_running_mean_info[key][oenv_digit] = \
i_running_mean_info[key][ienv_digit] * start_coeff
for key in ['mean', 'variance']:
o_running_mean_info[key][oenv_digit] = \
i_running_mean_info[key][ienv_digit]
else:
# the name format: "@type_@name_@number", e.g.: joint_leg_1
assert len(node_name.split('_')) == 3
# find all the repetitive node and calculate the average
repetitive_struct_node_list = [
ienv_node_name_list.index(name) for name in ienv_node_name_list
if node_name.split('_')[1] == name.split('_')[1]
]
assert len(repetitive_struct_node_list) >= 1
num_reptitive_nodes = float(len(repetitive_struct_node_list))
for i_node_id in repetitive_struct_node_list:
ienv_digit = ienv_info['input_dict'][i_node_id]
assert len(ienv_digit) == len(oenv_digit)
# assign the value!
for key in ['square_sum', 'sum']:
o_running_mean_info[key][oenv_digit] += \
i_running_mean_info[key][ienv_digit] * \
start_coeff / num_reptitive_nodes
for key in ['mean', 'variance']:
o_running_mean_info[key][oenv_digit] += \
i_running_mean_info[key][ienv_digit] / \
num_reptitive_nodes
return o_running_mean_info
"""
this is the test which has been taken from
- gated_graph_policy_network.py
- GGNN class
- _parse_mujoco_template function
"""
import graph_util.gnn_util as gnn_util
from graph_util.mujoco_parser import parse_mujoco_graph
_input_feat_dim = 64 # default value
node_info = parse_mujoco_graph(task_name="CentipedeFour-v1")
# step 2: check for ob size for each node type, construct the node dict
node_info = gnn_util.construct_ob_size_dict(node_info, _input_feat_dim)
# step 3: get the inverse node offsets (used to construct gather idx)
node_info = gnn_util.get_inverse_type_offset(node_info, 'node')
# step 4: get the inverse node offsets (used to gather output idx)
node_info = gnn_util.get_inverse_type_offset(node_info, 'output')
# step 5: register existing edge and get the receive and send index
node_info = gnn_util.get_receive_send_idx(node_info)
# step 6: get the stacked node params
node_info = gnn_util.get_stacked_node_params(node_info)
for key, item in node_info.items():
print("========")
import gym
from graph_util.mujoco_parser import parse_mujoco_graph, get_all_joint_names
env_name = "CentipedeFour-v1"
res = parse_mujoco_graph(task_name=env_name)
# print(res)
"""
dict(tree,
relation_matrix
node_type_dict,
output_type_dict,
input_dict,
output_list,
debug_info,
node_parameters,
para_size_dict,
num_nodes)
"""
for key, item in res.items():
print("========")
print(key, item)
joint_names = get_all_joint_names(env_name)
env = gym.make(env_name)
for joint_name in joint_names:
print(joint_name, "qpos: ", env.sim.model.get_joint_qpos_addr(joint_name))
print(joint_name, "qvel: ", env.sim.model.get_joint_qvel_addr(joint_name))
print("Num of joints: ", len(joint_names), env.sim.data.cfrc_ext.shape)
from graph_util.mujoco_parser import parse_mujoco_graph
res = parse_mujoco_graph(task_name="CentipedeFour-v1")
# print(res)
"""
dict(tree,
relation_matrix
node_type_dict,
output_type_dict,
input_dict,
output_list,
debug_info,
node_parameters,
para_size_dict,
num_nodes)
"""
for key, item in res.items():
print("========")
print(key, item)
