File size: 7,921 Bytes
2bb55ef | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | """
Test the linear interpolator on the Lift task with Sawyer arm environment as a test case.
The linear interpolator is meant to increase the stability and overall safety of a robot arm's trajectory when reaching
a setpoint, "ramping up" the actual action command sent to a given controller from zero to the actual inputted action
over a fraction of the timesteps in betwteen each high-level input action (the "ramp ratio"). As a result, the
resulting trajectory should be smoother, proportional to the interpolator's ramp ratio setting.
This test verifies that the linear interpolator works correctly on both the IK and OSC controller for both position and
orientation, and proceeds as follows:
1. Given a constant delta position action, and with the interpolator disabled, we will measure the sum of absolute
changes in joint torques between individual simulation timesteps
2. We will repeat Step 1, but this time with the interpolator enabled and with a ramp ratio of 1.0 (max value)
3. We expect the interpolated trajectories to experience a smaller overall magnitude of changes in torques, due to
the setpoints between controller timesteps being smoothed out over the ramp ratio.
Note: As this is a qualitative test, it is up to the user to evaluate the output and determine the expected behavior of
the tested controllers.
"""
import argparse
import json
import os
import numpy as np
import robosuite as suite
import robosuite.controllers.composite.composite_controller_factory as composite_controller_factory
import robosuite.utils.transform_utils as T
# Define the threshold locations, delta values, and ratio #
# Translation trajectory
pos_y_threshold = 0.1
delta_pos_y = 0.01
pos_action_osc = [0, delta_pos_y * 40, 0]
pos_action_ik = [0, delta_pos_y, 0]
# Rotation trajectory
rot_r_threshold = np.pi / 2
delta_rot_r = 0.01
rot_action_osc = [delta_rot_r * 40, 0, 0]
rot_action_ik = [delta_rot_r * 5, 0, 0]
# Concatenated thresholds and corresponding indexes (y = 1 in x,y,z; roll = 0 in r,p,y)
thresholds = [pos_y_threshold, rot_r_threshold]
indexes = [1, 0]
# Threshold ratio
min_ratio = 1.10
# Define arguments for this test
parser = argparse.ArgumentParser()
parser.add_argument("--render", action="store_true", help="Whether to render tests or run headless")
args = parser.parse_args()
# Setup printing options for numbers
np.set_printoptions(formatter={"float": lambda x: "{0:0.3f}".format(x)})
# function to run the actual sim in order to receive summed absolute delta torques
def step(env, action, current_torques):
env.timestep += 1
policy_step = True
summed_abs_delta_torques = np.zeros(7)
for i in range(int(env.control_timestep / env.model_timestep)):
env.sim.forward()
env._pre_action(action, policy_step)
last_torques = current_torques
current_torques = env.robots[0].composite_controller.part_controllers["right"].torques
summed_abs_delta_torques += np.abs(current_torques - last_torques)
env.sim.step()
policy_step = False
env.cur_time += env.control_timestep
out = env._post_action(action)
return out, summed_abs_delta_torques, current_torques
# Running the actual test #
def test_linear_interpolator():
for controller_name in [None, "BASIC"]: # None corresponds to robot's default controller
for traj in ["pos", "ori"]:
# Define counter to increment timesteps and torques for each trajectory
timesteps = [0, 0]
summed_abs_delta_torques = [np.zeros(7), np.zeros(7)]
for interpolator in [None, "linear"]:
# Define numpy seed so we guarantee consistent starting pos / ori for each trajectory
np.random.seed(3)
# load a composite controller
controller_config = composite_controller_factory.load_composite_controller_config(
controller=controller_name,
robot="Sawyer",
)
# Now, create a test env for testing the controller on
env = suite.make(
"Lift",
robots="Sawyer",
has_renderer=args.render, # by default, don't use on-screen renderer for visual validation
has_offscreen_renderer=False,
use_camera_obs=False,
horizon=10000,
control_freq=20,
controller_configs=controller_config,
)
# Reset the environment
env.reset()
# Hardcode the starting position for sawyer
init_qpos = [-0.5538, -0.8208, 0.4155, 1.8409, -0.4955, 0.6482, 1.9628]
env.robots[0].set_robot_joint_positions(init_qpos)
env.robots[0].composite_controller.part_controllers["right"].update_initial_joints(init_qpos)
env.robots[0].composite_controller.part_controllers["right"].reset_goal()
# Notify user a new trajectory is beginning
print(
"\nTesting controller {} with trajectory {} and interpolator={}...".format(
controller_name, traj, interpolator
)
)
# If rendering, set controller to front view to get best angle for viewing robot movements
if args.render:
env.viewer.set_camera(camera_id=0)
# Keep track of state of robot eef (pos, ori (euler)) and torques
current_torques = np.zeros(7)
initial_state = [env.robots[0]._hand_pos["right"], T.mat2quat(env.robots[0]._hand_orn["right"])]
dstate = [
env.robots[0]._hand_pos["right"] - initial_state[0],
T.mat2euler(
T.quat2mat(T.quat_distance(T.mat2quat(env.robots[0]._hand_orn["right"]), initial_state[1]))
),
]
# Define the uniform trajectory action
if traj == "pos":
pos_act = pos_action_osc
rot_act = np.zeros(3)
else:
pos_act = np.zeros(3)
rot_act = rot_action_osc
# Compose the action
action = np.concatenate([pos_act, rot_act, [0]])
# Determine which trajectory we're executing
k = 0 if traj == "pos" else 1
j = 0 if not interpolator else 1
# Run trajectory until the threshold condition is met
while abs(dstate[k][indexes[k]]) < abs(thresholds[k]):
_, summed_torques, current_torques = step(env, action, current_torques)
if args.render:
env.render()
# Update torques, timestep count, and state
summed_abs_delta_torques[j] += summed_torques
timesteps[j] += 1
dstate = [
env.robots[0]._hand_pos["right"] - initial_state[0],
T.mat2euler(
T.quat2mat(T.quat_distance(T.mat2quat(env.robots[0]._hand_orn["right"]), initial_state[1]))
),
]
# When finished, print out the timestep results
print(
"Completed trajectory. Avg per-step absolute delta torques: {}".format(
summed_abs_delta_torques[j] / timesteps[j]
)
)
# Shut down this env before starting the next test
env.close()
# Tests completed!
print()
print("-" * 80)
print("All linear interpolator testing completed.\n")
if __name__ == "__main__":
test_linear_interpolator()
|