def test_local_folder_envs():
env = sensenet.make("MyEnv")
assert env.action_space.n
reset_observation = env.reset()
assert (reset_observation is not None)
observation = env.step(0)
assert observation != None
env = sensenet.make("CrazyEnv")
assert env.action_space.n
reset_observation = env.reset()
assert (reset_observation is not None)
observation = env.step(0)
assert observation != None
def main():
parser = argparse.ArgumentParser(description=None)
parser.add_argument('-v',
'--verbose',
action='count',
dest='verbosity',
default=0,
help='Set verbosity.')
parser.add_argument('-e',
'--environment',
dest='environment',
default='HandEnv-v0',
help='Set environment')
args = parser.parse_args()
if args.verbosity == 0:
logger.setLevel(logging.INFO)
elif args.verbosity >= 1:
logger.setLevel(logging.DEBUG)
env = sensenet.make(args.environment, {'render': True})
#env = gym.make('MountainCar-v0')
observation_n = env.reset()
while True:
# your agent here
env.render()
action_n = env.action_space.sample()
observation_n, reward_n, done_n, info = env.step(action_n)
return 0
def test_core_envs():
env = sensenet.make("HandEnv-v0")
assert env.action_space.n
reset_observation = env.reset()
assert (reset_observation is not None)
observation = env.step(0)
assert observation != None
def main():
parser = argparse.ArgumentParser(description=None)
parser.add_argument('-v', '--verbose', action='count', dest='verbosity', default=0, help='Set verbosity.')
args = parser.parse_args()
if args.verbosity == 0:
logger.setLevel(logging.INFO)
elif args.verbosity >= 1:
logger.setLevel(logging.DEBUG)
env = sensenet.make("HandEnv-v0",{'render':True})
observation_n = env.reset()
while True:
# your agent here
action_n = random.choice(env.action_space())
observation_n, reward_n, done_n, info = env.step(action_n)
return 0
def test_envs_follow_api():
env_names = [spec.id for spec in envs.registry.all()]
for name in env_names:
print("loading env", name)
env = sensenet.make(name)
assert env.action_space.n
reset_observation = env.reset()
#TODO write test to confirm observation space is the same for the reset and step function
#assert env.observation_space == reset_observation.shape
assert (reset_observation is not None)
observation = env.step(0)
assert observation != None
#put any methods in here to test exceptions
try:
#end.seed(42)
env.reset()
env.render()
assert True
except:
raise Exception('spam', 'eggs')
rewards.insert(0, R)
rewards = torch.Tensor(rewards)
rewards = (rewards - rewards.mean()) / (rewards.std() + np.finfo(np.float32).eps)
for log_prob, reward in zip(policy.saved_log_probs, rewards):
policy_loss.append(-log_prob * reward)
optimizer.zero_grad()
policy_loss = torch.cat(policy_loss).sum()
policy_loss.backward()
optimizer.step()
del model.rewards[:]
del model.saved_log_probs[:]
# Training:
env = sensenet.make(args.environment,vars(args))
print("action space: ",env.action_space,env.action_space.n)
print("class count: ",env.classification_n())
policy = Policy(env.observation_space.shape[0] * env.observation_space.shape[1],env.action_space.n)
cnn_lstm = CNNLSTM(env.classification_n())
if args.gpu and torch.cuda.is_available():
policy.cuda()
cnn_lstm.cuda()
if model_path:
if os.path.exists(model_path+"/model.pkl"):
print("loading pretrained models")
policy.load_state_dict(torch.load(model_path+"/model.pkl"))
cnn_lstm.load_state_dict(torch.load(model_path+"/cnn_lstm.pkl"))
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(policy.parameters(), lr=args.lr)
def test_envs():
print(envs.registry.all())
env = sensenet.make("HandEnv-v0")
env2 = sensenet.make("MyEnv")
parser = argparse.ArgumentParser()
parser.add_argument('--render',
action='store_true',
help='render the environment')
parser.add_argument('--environment', "-e", type=str, default="HandEnv-v0")
parser.add_argument('--epochs', type=int, default=1)
parser.add_argument('--folder', type=str)
parser.add_argument('--file', type=str)
parser.add_argument('--fast_exit', type=int, default=0)
args = parser.parse_args()
if args.folder:
files = list(glob.iglob(args.folder + "/**/*.obj", recursive=True))
else:
files = [args.file]
random.shuffle(files)
env = sensenet.make(args.environment, {'render': args.render})
for filename in files:
label = int(filename.split("/")[-3].split("_")[0])
print(filename)
print(label)
path = "touch_data/" + str(label) + "/"
env._reset({'obj_path': filename})
env.mkdir_p(path)
training_sets = []
observations = []
actions = []
touch_count = 0
step = 0
episode = 0
plan_step = 0
tries = 0
def test_envs_have_spaces():
env_names = [spec.id for spec in envs.registry.all()]
for name in env_names:
print("loading env", name)
env = sensenet.make(name)
assert env.action_space.n #TODO fix assertion to test for valid assertion
import sys
import sensenet
import pybullet as p
if len(sys.argv) >= 2:
model_file = sys.argv[1]
print("loading model", model_file)
env = sensenet.make(name_to_env(model_file))
p.startStateLogging(p.STATE_LOGGING_VIDEO_MP4, (model_file+"_recording.mp4"))
#model = sensenet.get_model name_to_pymodel(model_file)
observation = env.reset()
steps = 0
total_steps = 0
episode_count = 0
def select_action(state,n_actions,model):
state = torch.from_numpy(state).float().unsqueeze(0)
probs = model(Variable(state))
action = probs.multinomial()
return action.data[0][0]
while (1):
if total_steps%100=0:
print("total steps ...",total_steps)
print("episode ",episode_count," step ", steps)
if done:
env.reset()
episode_count += 1
steps = 0
action = select_action(observation,observation,model)
observation,reward,done,info = env.step(action)
steps +=1
total_steps += 1
type=int,
default=543,
metavar='N',
help='random seed (default: 543)')
parser.add_argument('--render',
action='store_true',
help='render the environment')
parser.add_argument('--log-interval',
type=int,
default=10,
metavar='N',
help='interval between training status logs (default: 10)')
args = parser.parse_args()
#env = gym.make('CartPole-v0')
env = sensenet.make("TouchWandEnv-v0", {'render': True})
#env.seed(args.seed)
torch.manual_seed(args.seed)
class Policy(nn.Module):
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(3, 128)
self.affine2 = nn.Linear(128, 6)
self.saved_log_probs = []
self.rewards = []
def forward(self, x):
x = F.relu(self.affine1(x))
import sys
import sensenet
if len(sys.argv) >= 2:
env_id = sys.argv[1]
print("loading env", env_id)
else:
print("must pass env as arg")
env = sensenet.make(env_id,{'render':True,'random_orientation':True})
env.reset()
while (1):
key = env.getKeyboardEvents()
n = -1
if len(key.keys()) >= 2:
m = 0
if 65307 in key.keys(): #shift
m = 10
elif 65306 in key.keys(): #control
m = 20
for k in key.keys():
if k in range(48,58):
n = k-48+m
else:
for k in key.keys():
if k == 113: #q
if action_mode == True:
action_mode = False
else:
action_mode = True
elif k in range(48,58):
n = k-48
else:
def test_reset_can_set_obj():
#test if we can load an arbitrary path
env = sensenet.make("TouchWandEnv-v0",{'obj_path':'./data/cube.stl'})
assert env.options['obj_path'], "./data/cube.stl"
env._reset({'obj_path':'./data/sphere.stl'})
assert env.options['obj_path'], "./data/sphere.stl"
import sensenet, argparse
parser = argparse.ArgumentParser(description='SenseNet')
parser.add_argument('--render',
action='store_false',
help='render the environment')
parser.add_argument('--debug', action='store_true', help='debug')
parser.add_argument('--environment', '-e', type=str, default="HandEnv-v0")
args = parser.parse_args()
env = sensenet.make(args.environment, {
'render': args.render,
'debug': args.debug
})
env.reset()
while (1):
key = env.getKeyboardEvents()
n = -1
if len(key.keys()) >= 2:
m = 0
if 65307 in key.keys(): #shift
m = 10
elif 65306 in key.keys(): #control
m = 20
for k in key.keys():
if k in range(48, 58):
n = k - 48 + m
else:
for k in key.keys():
if k == 113: #q
if action_mode == True:
action_mode = False
def test_class_count():
env = sensenet.make("HandEnv-v0", {'data_path': 'data/1class_folder'})
assert env.classification_n() == 1
env = sensenet.make("HandEnv-v0", {'data_path': 'data/2class_folder'})
assert env.classification_n() == 2
#load a stl/obj file as argv[1]
import sys
import sensenet
from random import randint
env = sensenet.make("BlankEnv-v0", {'render': True, 'obj_path': sys.argv[1]})
done = False
while (1):
if done:
env.reset()
action = randint(0, 1)
#action = randint(0, env.action_space.n)
observation, reward, done, info = env.step(action)
import sys
sys.path.append('..')
import sensenet
if len(sys.argv) >= 2:
env_id = sys.argv[1]
print("loading env", env_id)
env = sensenet.make(env_id, {'render': True})
env.reset()
while (1):
key = env.getKeyboardEvents()
n = -1
if len(key.keys()) >= 2:
m = 0
if 65307 in key.keys(): #shift
m = 10
elif 65306 in key.keys(): #control
m = 20
for k in key.keys():
if k in range(48, 58):
n = k - 48 + m
else:
for k in key.keys():
if k == 113: #q
if action_mode == True:
action_mode = False
else:
action_mode = True
elif k in range(48, 58):
n = k - 48
# print("new number",n)
rewards.insert(0, R)
rewards = torch.Tensor(rewards)
rewards = (rewards - rewards.mean()) / (rewards.std() + np.finfo(np.float32).eps)
for action, r in zip(model.saved_actions, rewards):
action.reinforce(r)
optimizer.zero_grad()
autograd.backward(model.saved_actions, [None for _ in model.saved_actions])
optimizer.step()
del model.rewards[:]
del model.saved_actions[:]
# Training:
#env = HandEnv(vars(args))
env = sensenet.make("HandEnv-v0",vars(args))
print("action space: ",env.action_space(),env.action_space_n())
print("class count: ",env.classification_n())
model = Policy(env.observation_space(),env.action_space_n())
cnn_lstm = CNNLSTM(env.classification_n())
if args.gpu and torch.cuda.is_available():
model.cuda()
cnn_lstm.cuda()
if model_path:
if os.path.exists(model_path+"/model.pkl"):
print("loading pretrained models")
model.load_state_dict(torch.load(model_path+"/model.pkl"))
cnn_lstm.load_state_dict(torch.load(model_path+"/cnn_lstm.pkl"))
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
def __init__(self, tuning_parameters):
EnvironmentWrapper.__init__(self, tuning_parameters)
# env parameters
if ':' in self.env_id:
self.env = sensenet.envs.registration.load(self.env_id)()
else:
self.env = sensenet.make(self.env_id)
if self.seed is not None:
self.env.seed(self.seed)
# self.env_spec = gym.spec(self.env_id)
self.env.frameskip = self.frame_skip
self.discrete_controls = type(
self.env.action_space) != sensenet.spaces.box.Box
self.state = self.reset(True)['state']
# render
if self.is_rendered:
image = self.get_rendered_image()
scale = 1
if self.human_control:
scale = 2
self.renderer.create_screen(image.shape[1] * scale,
image.shape[0] * scale)
#if isinstance(self.env.observation_space, sensenet.spaces.Dict):
# if 'observation' not in self.env.observation_space:
# raise ValueError((
# 'The SenseNet environment provided {env_id} does not contain '
# '"observation" in its observation space. For now this is '
# 'required. The environment does include the following '
# 'keys in its observation space: {keys}'
# ).format(
# env_id=self.env_id,
# keys=self.env.observation_space.keys(),
# ))
# TODO: collect and store this as observation space instead
self.is_state_type_image = len(self.state['observation'].shape) > 1
if self.is_state_type_image:
self.width = self.state['observation'].shape[1]
self.height = self.state['observation'].shape[0]
else:
self.width = self.state['observation'].shape[0]
# action space
self.actions_description = {}
if hasattr(self.env.unwrapped, 'get_action_meanings'):
self.actions_description = self.env.unwrapped.get_action_meanings()
if self.discrete_controls:
self.action_space_size = self.env.action_space.n
self.action_space_abs_range = 0
else:
self.action_space_size = self.env.action_space.shape[0]
self.action_space_high = self.env.action_space.high
self.action_space_low = self.env.action_space.low
self.action_space_abs_range = np.maximum(
np.abs(self.action_space_low), np.abs(self.action_space_high))
self.actions = {i: i for i in range(self.action_space_size)}
self.key_to_action = {}
if hasattr(self.env.unwrapped, 'get_keys_to_action'):
self.key_to_action = self.env.unwrapped.get_keys_to_action()
# measurements
if self.env.spec is not None:
self.timestep_limit = self.env.spec.timestep_limit or self.env.timestep_limit
else:
self.timestep_limit = None
import sys
sys.path.append('..')
import sensenet
import random
import pybullet as p
if len(sys.argv) > 1:
envid = sys.argv[1]
else:
envid = "HandEnv-v0"
if len(sys.argv) > 2:
obj_path = sys.argv[2]
else:
obj_path = None
#TODO add support for folders,classes, and saving data
env = sensenet.make(envid, {'render': True, 'obj_path': obj_path})
env.reset()
forward = 3
left = 0
right = 1
up = 4
down = 5
indexup = 6
indexdown = 7
action_choices = [forward, left, right, up, down] #dont move index for now
training_sets = []
observations = []
actions = []
touch_count = 0
