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