def init(self):
self.init_pose = np.array(
np.concatenate([[float(random.randint(0, 10)) for x in range(3)],
[0., 0., 0.]]))
self.target_pos = np.array(
[float(random.randint(0, 10)) for x in range(3)])
self.sim = PhysicsSim(self.init_pose, None, None, self.runtime)
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 400
self.action_high = 900
self.action_size = 4
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
# Level flight not spinning in any direction
self.target_angles = np.array([0.,0.,0.])
self.target_Ang_V = np.array([0., 0., 0.])
# We should only be going up. Only Z velocity is a target
self.target_v = init_velocities if init_velocities is not None else np.array([0., 0., 10.])
self.init_pose = init_pose
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = 27 #27 or 18
self.action_low = 0
self.action_high = 900
self.action_size = 4
# variable to calculate reward and monitor
self.last_z = 0
self.last_vel = np.array((0, 0, 0))
self.step_taken = 0
self.last_rotor_speeds = np.array((0, 0, 0, 0))
self.rotor_speed_change = np.array((0, 0, 0, 0))
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10., 0., 0., 0.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 7 #4 # 6 ... x,y,z, time
self.action_low = 50
self.action_high = 400
self.action_size = 4
self.runtime = runtime
self.agent_distance = -np.inf
self.raw_reward = 0.0
self.counter = 0
self.avg_dist = 0
self.sum_dist = 0
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=1.):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 0
self.action_high = 900
self.action_size = 4
# Goal, maximize this distance
self.init_pose = init_pose
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, min_height=1., reward_weights = None, runtime=5.):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
min_height: minimum height to maintain in meters
runtime: time limit for each episode in seconds
"""
# Simulation
self.init_pose = init_pose if init_pose is not None else np.array([0.,0.,10.,0.,0.,0.])
self.init_velocities = init_velocities if init_velocities is not None else np.zeros(3)
self.init_angle_velocities = init_angle_velocities if init_angle_velocities is not None else np.zeros(3)
self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 12 # 6 pose + 6 velocity
self.action_low = 0 # Min RPM value
self.action_high = 900 # Max RPM value
self.action_size = 4 # Num actions (4 rotors)
self.last_rotor_speeds = None
self.curr_rotor_speeds = None
# Goal
self.target_pos = init_pose[0:3] if init_pose is not None else np.array([0., 0., 10.])
self.reward_weights = reward_weights if reward_weights is not None else np.array([10.,0.,-2.,-1.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None,
action_repeat=3,
debug=False):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = int(action_repeat)
self.state_size = self.action_repeat * self.sim.pose.shape[0]
self.action_low = 1
self.action_high = 900
self.action_size = 4
self.runtime = runtime
self.debug = debug
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * len(self.sim.pose[2:]+[self.sim.time])
# self.state_size = self.action_repeat * 1
self.action_low = 300.
self.action_high = 600.
self.action_size = 4
self.num_steps = 0
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 375 # constrain propeller speeds to reasonable range
self.action_high = 450
self.action_size = 1
self.total_reward = 0
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self, reward_function, init_pose=None, runtime=5.):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
self.reward_function = reward_function
self.init_pose = init_pose if init_pose is not None else np.array(
[0.0, 0.0, 10.0, 0.0, 0.0, 0.0])
# Simulation
self.sim = PhysicsSim(self.init_pose, np.array([0.0, 0.0, 0.0]),
np.array([0.0, 0.0, 0.0]), runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 0
self.action_high = 900
self.action_size = 1
# Goal, same as the initial position
self.target_pos = np.array(self.init_pose[:3])
def __init__(self, init_pose=np.array([0.0, 0.0, 10.0, 0.0, 0.0, 0.0]), init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None, action_repeat=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
self.action_repeat = action_repeat if action_repeat is not None else 3
self.init_pos = init_pose
self.state_size = self.action_repeat * 6
self.action_low = 10
self.action_high = 900
self.action_size = 4
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
self.flight_path = self.target_pos - self.init_pos[:3]
self.num_steps = 0
def __init__(self, init_pose=None, runtime=5., target_elevation=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
if init_pose[2] > target_elevation or target_elevation is None:
raise ValueError(
'Target elevation must be higher than current position!')
# Init Values
init_pose = init_pose if init_pose is not None else np.array(
[0., 0., 1., 0., 0., 0.])
init_velocities = np.array([0., 0., 0.])
init_angle_velocities = np.array([0., 0., 0.])
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 9
self.action_low = 0
self.action_high = 900
self.action_size = 1
self.target_pos = np.copy(init_pose[:3])
self.target_pos[2] = target_elevation
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
def get_propeler_thrust(self, rotor_speeds):
'''calculates net thrust (thrust - drag) based on velocity
of propeller and incoming power'''
thrusts = []
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
#You can use only [z_pos, z_speed], so it would be much easier for the agent to learn and train.
#[self.sim.pose[2], self.sim.v[2]]
self.action_repeat = 3
self.state_size = self.action_repeat * 6 #making state size larger
self.action_low = 0
self.action_high = 900
self.action_size = 4 #4 rotors?
#for reward function
self.z_bonus = 5.0 #tried 5 but I think a huge reward is better like 10
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.]) #txyz so this is takeoff
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None, reward_func=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
self.start_pos = self.sim.pose[:3]
self.action_repeat = 3
# state made of current position, velocity and angular velocity
self.state_size = self.action_repeat * (6 + 3 + 3)
self.action_low = 0
self.action_high = 900
self.action_size = 4
self.runtime = runtime
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
self.reward_func = reward_func
self.penalties_obj = {}
self.penalties = 0
self.reward = 0
def __init__(self, action_repeat=3, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None, reward_gains=np.array([0, 0, 0, 0, 0, 0])):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
#self.action_repeat = 3
self.action_repeat = action_repeat #if action_repeat is None else 1
# SRS: Adjust sise according to all features in state
self.state_size = int(self.action_repeat * (6+3+0*3))
self.action_low = 0
self.action_high = 900
self.action_size = 4
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10., 0.,0.,0., 0.,0.,0.])
# Reward gains
self.reward_gains = reward_gains
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pose=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pose: target/goal (x,y,z & eular angles) pose for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6 # six dimensional pose
self.action_low = 10 # 0 was original value
self.action_high = 900
self.action_size = 4
# Default goal if not set
self.target_pose = target_pose if target_pose is not None else np.array(
[0., 0., 10., 0., 0., 0.])
print('Initial vel = ', self.sim.init_velocities)
print('Initial angle vel = ', self.sim.init_angle_velocities)
print('Initial pose = ', self.sim.init_pose)
print('Target pose = ', self.target_pose)
def __init__(self,
runtime=5.,
init_pose=np.array([0.0, 0.0, 10.0, 0.0, 0.0, 0.0]),
init_velocities=np.array([0.0, 0.0, 0.0]),
init_angle_velocities=np.array([0.0, 0.0, 0.0]),
pos_noise=0.25,
angle_noise=None,
velocity_noise=0.15,
velocity_angle_noise=None,
target_pos=np.array([0.0, 0.0, 10.0])):
self.target_pos = target_pos
self.pos_noise = pos_noise
self.angle_noise = angle_noise
self.velocity_noise = velocity_noise
self.velocity_angle_noise = velocity_angle_noise
self.action_size = 1
self.action_repeat = 1
self.action_high = 1.2 * 400
self.action_low = 0.99 * 400
self.noise = OUNoise(self.action_size, mu=0.0, theta=0.2, sigma=0.1)
self.action_b = (self.action_high + self.action_low) / 2.0
self.action_m = (self.action_high - self.action_low) / 2.0
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.state_size = len(self.get_state())
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.runtime = runtime
self.init_angle_velocities = init_angle_velocities
self.sim = PhysicsSim(init_pose, init_velocities,
self.init_angle_velocities, self.runtime)
self.action_repeat = ACTION_REPEAT # changed from previous setting of 3 to give more dynamic response
self.target_pos = target_pos
self.action_size = 4
self.state_size = self.action_repeat * (len(self.sim.pose) +
self.action_size)
self.action_low = 0
self.action_high = 900
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
# randomize start
self.randomize()
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_trajectory: Union[type(None),
Callable[[float], np.array]] = None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_trajectory: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 0
self.action_high = 900
self.action_size = 4
# Goal
self.target_trajectory = target_trajectory if target_trajectory is not None else lambda t: np.array(
[0., 0., 10.])
def __init__(self, init_pose=None, init_velocities=None,
init_angle_velocities=None, runtime=5., target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
target_orientation: target/goal (phi, theta, psi) Euler angles in radians
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities, init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 9
self.action_low = 0
self.action_high = 900
# self.action_size = 4
self.action_size = 1
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
self.weight_pos = 2.3
self.weight_velocity = 0.9
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.初始化指定本任务所需的几个变量
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3 # 重复调用动作次数
self.state_size = self.action_repeat * 6 # 状态向量中每个分量的数值
self.action_low = 0 # 动作最小值
self.action_high = 900 # 动作最大值
self.action_size = 4 # 四维动作空间
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles pitch yaw roll
runtime: time limit for each episode (This makes it an episodic task)
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 0 ## lowest roter speed
self.action_high = 900 ## highest roter speed
self.action_size = 4 ## 4 roter speeds
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = 2 * self.action_repeat
self.action_low = 0
self.action_high = 900
self.action_size = 4
self.step_count = 0
self.max_iteration = 100
# Goal
self.target_pos = np.array([0., 0., 10.])
self.target_vel = np.array([0., 0., 0.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 425
self.action_high = 475
self.action_size = 4
# number of steps in episode:
self.steps = 0
# current distance from target:
self.distance = np.linalg.norm(self.target_pos - self.sim.pose[:3])
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self, init_pose, init_velocities,
init_angle_velocities, runtime=5., target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
# AE: Initial state will contain pose (position and angles of the copter)
# AE: and the copter dimensional velocities (speed)
self.initial_state = np.concatenate((init_pose, init_velocities))
# AE: We are not allowed to change physics_sim.py, but it will only work with a 6-dimensional
# AE: state, so I must trim it here, but for my Neural Networks, I will use the full state.
self.sim = PhysicsSim(self.initial_state[:6], init_velocities, init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * len(self.initial_state)
self.action_low = 400
self.action_high = 900
self.action_size = 4
# Goal
self.target_pos = target_pos if target_pos is not None else np.array([0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=-1.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 3
self.action_low = 0
self.action_high = 900
self.action_size = 1
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
self.box_size = 4.
self.half_box_size = (self.box_size / 2.)
self.ceiling = self.target_pos[2] + self.half_box_size
self.floor = self.target_pos[2] - self.half_box_size
def __init__(self,
target_pos,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 1
self.state_size = self.action_repeat * 6
self.action_low = 0
self.action_high = 900
self.action_size = 4
self.init_pose = self.sim.pose
self.old_pose = self.sim.pose
# Goal
self.target_pos = target_pos
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.unique_state_size = np.concatenate(
([self.sim.pose] + [self.sim.v] + [self.sim.angular_v])).shape[0]
self.state_size = self.action_repeat * self.unique_state_size
self.action_low = 0
self.action_high = 900
self.action_size = 4
# Origin
self.init_pose = init_pose
# Goal
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self,
init_pose=None,
init_velocities=None,
init_angle_velocities=None,
runtime=5.,
target_pos=None):
"""Initialize a Task object.
Params
======
init_pose: initial position of the quadcopter in (x,y,z) dimensions and the Euler angles
init_velocities: initial velocity of the quadcopter in (x,y,z) dimensions
init_angle_velocities: initial radians/second for each of the three Euler angles
runtime: time limit for each episode
target_pos: target/goal (x,y,z) position for the agent
"""
# Simulation
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.action_repeat = 3
self.state_size = self.action_repeat * 6
self.action_low = 0
self.action_high = 900
self.action_size = 4
# Goal
if target_pos is None:
print("Setting default init pose")
self.target_pos = target_pos if target_pos is not None else np.array(
[0., 0., 10.])
def __init__(self,
runtime=5.,
target_pos=None,
init_pose=np.array([0.0, 0.0, 10.0, 0.0, 0.0, 0.0]),
init_velocities=np.array([0.0, 0.0, 0.0]),
init_angle_velocities=np.array([0.0, 0.0, 0.0]),
pos_noise=None,
vel_noise=None,
ang_noise=None,
ang_vel_noise=None):
self.action_low = 400
self.action_high = 420
self.action_size = 1
self.pos_noise = 0.25
self.vel_noise = 0.15
self.target_pos = target_pos
self.ang_noise = ang_noise
self.ang_vel_noise = ang_vel_noise
self.sim = PhysicsSim(init_pose, init_velocities,
init_angle_velocities, runtime)
self.state_size = len(self.get_state())
self.action_b = (self.action_high + self.action_low) / 2.0
self.action_m = (self.action_high - self.action_low) / 2.0
