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)