def eval_recall(imgs_enc, caps_enc):
imgs_enc = np.vstack(flatten(imgs_enc))
caps_enc = np.vstack(flatten(caps_enc))
res = avg_recall(imgs_enc, caps_enc)
return res
def build_network_rnn(self):
self.states = tf.placeholder(tf.float32, [None] +
list(self.env.observation_space.shape),
name="states") # Observation
# self.n_states = tf.placeholder(tf.float32, shape=[None], name="n_states") # Observation
self.a_n = tf.placeholder(tf.float32, name="a_n") # Discrete action
self.adv_n = tf.placeholder(tf.float32, name="adv_n") # Advantage
n_states = tf.shape(self.states)[:1]
states = tf.expand_dims(flatten(self.states), [0])
enc_cell = tf.contrib.rnn.GRUCell(self.config["n_hidden_units"])
L1, _ = tf.nn.dynamic_rnn(cell=enc_cell,
inputs=states,
sequence_length=n_states,
dtype=tf.float32)
L1 = L1[0]
mu, sigma = mu_sigma_layer(L1, 1)
self.normal_dist = tf.contrib.distributions.Normal(mu, sigma)
self.action = self.normal_dist.sample(1)
self.action = tf.clip_by_value(self.action,
self.env.action_space.low[0],
self.env.action_space.high[0])
def build_network(self):
self.rnn_state = None
self.states = tf.placeholder(tf.float32, [None] +
list(self.env.observation_space.shape),
name="states") # Observation
# self.n_states = tf.placeholder(tf.float32, shape=[None], name="n_states") # Observation
self.a_n = tf.placeholder(tf.float32, name="a_n") # Discrete action
self.adv_n = tf.placeholder(tf.float32, name="adv_n") # Advantage
n_states = tf.shape(self.states)[:1]
states = tf.expand_dims(flatten(self.states), [0])
enc_cell = tf.contrib.rnn.GRUCell(self.config["n_hidden_units"])
self.rnn_state_in = enc_cell.zero_state(1, tf.float32)
L1, self.rnn_state_out = tf.nn.dynamic_rnn(
cell=enc_cell,
inputs=states,
sequence_length=n_states,
initial_state=self.rnn_state_in,
dtype=tf.float32)
self.probs = tf.contrib.layers.fully_connected(
inputs=L1[0],
num_outputs=self.env_runner.nA,
activation_fn=tf.nn.softmax,
weights_initializer=tf.truncated_normal_initializer(mean=0.0,
stddev=0.02),
biases_initializer=tf.zeros_initializer())
self.action = tf.squeeze(tf.multinomial(tf.log(self.probs), 1),
name="action")
def build_network(self):
self.rnn_state = None
self.a_n = tf.placeholder(tf.float32, name="a_n") # Discrete action
self.adv_n = tf.placeholder(tf.float32, name="adv_n") # Advantage
image_size = 80
image_depth = 1 # aka nr. of feature maps. Eg 3 for RGB images. 1 here because we use grayscale images
self.states = tf.placeholder(
tf.float32, [None, image_size, image_size, image_depth],
name="states")
self.N = tf.placeholder(tf.int32, name="N")
x = self.states
# Convolution layers
for i in range(4):
x = tf.nn.elu(conv2d(x, 32, "l{}".format(i + 1), [3, 3], [2, 2]))
# Flatten
shape = x.get_shape().as_list()
reshape = tf.reshape(x, [-1, shape[1] * shape[2] * shape[3]
]) # -1 for the (unknown) batch size
reshape = tf.expand_dims(flatten(reshape), [0])
self.enc_cell = tf.contrib.rnn.BasicLSTMCell(
self.config["n_hidden_units"])
self.rnn_state_in = self.enc_cell.zero_state(1, tf.float32)
self.L3, self.rnn_state_out = tf.nn.dynamic_rnn(
cell=self.enc_cell,
inputs=reshape,
initial_state=self.rnn_state_in,
dtype=tf.float32)
self.probs = tf.contrib.layers.fully_connected(
inputs=self.L3[0],
num_outputs=self.env_runner.nA,
activation_fn=tf.nn.softmax,
weights_initializer=tf.truncated_normal_initializer(mean=0.0,
stddev=0.02),
biases_initializer=tf.zeros_initializer())
self.action = tf.squeeze(tf.multinomial(tf.log(self.probs), 1),
name="action")
def dantam_distract(env, n_obj): # (Incremental Task and Motion Planning: A Constraint-Based Approach)
assert REARRANGEMENT
env.Load(ENVIRONMENTS_DIR + 'empty.xml')
m, n = 3, 3
#m, n = 5, 5
side_dim = .07 # .05 | .07
height_dim = .1
box_dims = (side_dim, side_dim, height_dim)
separation = (side_dim, side_dim)
#separation = (side_dim/2, side_dim/2)
coordinates = list(product(range(m), range(n)))
assert n_obj <= len(coordinates)
obj_coordinates = sample(coordinates, n_obj)
length = m*(box_dims[0] + separation[0])
width = n*(box_dims[1] + separation[1])
height = .7
table = box_body(env, length, width, height, name='table', color=get_color('tan1'))
set_point(table, (0, 0, 0))
env.Add(table)
robot = env.GetRobots()[0]
set_default_robot_config(robot)
set_base_values(robot, (-1.5, 0, 0))
#set_base_values(robot, (0, width/2 + .5, math.pi))
#set_base_values(robot, (.35, width/2 + .35, math.pi))
#set_base_values(robot, (.35, width/2 + .35, 3*math.pi/4))
poses = []
z = get_point(table)[2] + height + BODY_PLACEMENT_Z_OFFSET
for r in range(m):
row = []
x = get_point(table)[0] - length/2 + (r+.5)*(box_dims[0] + separation[0])
for c in range(n):
y = get_point(table)[1] - width/2 + (c+.5)*(box_dims[1] + separation[1])
row.append(Pose(pose_from_quat_point(unit_quat(), np.array([x, y, z]))))
poses.append(row)
initial_poses = {}
goal_poses = {}
# TODO - randomly assign goal poses here
for i, (r, c) in enumerate(obj_coordinates):
row_color = np.zeros(4)
row_color[2-r] = 1.
if i == 0:
name = 'goal%d-%d'%(r, c)
color = BLUE
goal_poses[name] = poses[m/2][n/2]
else:
name = 'block%d-%d'%(r, c)
color = RED
initial_poses[name] = poses[r][c]
obj = box_body(env, *box_dims, name=name, color=color)
set_pose(obj, poses[r][c].value)
env.Add(obj)
#for obj in randomize(objects):
# randomly_place_body(env, obj, [get_name(table)])
known_poses = list(flatten(poses))
#known_poses = list(set(flatten(poses)) - {poses[r][c] for r, c in obj_coordinates}) # TODO - put the initial poses here
return ManipulationProblem(function_name(inspect.stack()),
object_names=initial_poses.keys(), table_names=[get_name(table)],
goal_poses=goal_poses,
initial_poses=initial_poses, known_poses=known_poses)