def main(): precision = torch.float # Parameter and Object declarations env_params = { "data path": "C:/Users/aaa2cn/Documents/nao_data/", "ip": "localhost", "port": 52232, "score type": "score" # Aggregate error in pose } env = env_factory.make_env("nao", "pose assumption", env_params) # Make a pool object model_params = { "precision": precision, "weight initialization scheme": "Sparse", "grad": False } model = model_factory.make_model("NAO FC model", model_params) # Make an algorithm object alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, "tolerance": 0.1, "max steps": 64, "memory size": 10 } alg = algorithm_factory.make_alg("local search", model, alg_params) experiment = Experiment(api_key="5xNPTUDWzZVquzn8R9oEFkUaa", project_name="nao", workspace="aromorin") experiment.set_name("Pose Assumption virtual") hyper_params = { "Algorithm": "LS", "Parameterization": 35000, "Decay Factor": 0.01, "Directions": 10, "Search Radius": 0.1 } experiment.log_parameters(hyper_params) slv_params = {"environment": env, "algorithm": alg, "logger": experiment} slv = solver_factory.make_slv("robot", slv_params) slv.solve(iterations=5000) slv.save_elite_weights(path='', name='pose_assump_virtual') # Recreate the target pose alg.eval() pred = alg.model(env.observation) angles = [p.item() for p in pred] print("These are the angles: ") print(angles) env.set_joints(angles) env.say("Is this the pose you set for me?") env.rest()
def main(): # Variable definition #module = 'RoboschoolPong-v1' #module = "RoboschoolReacher-v1" #module = "RoboschoolAnt-v1" module = "RoboschoolInvertedPendulum-v1" #module = "RoboschoolHumanoidFlagrunHarder-v1" #module = "RoboschoolAtlasForwardWalk-v1" # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": False, "module name": module } env = env_factory.make_env("openai", "roboschool", env_params) #print(env.action_space.low) #print(env.action_space.high) #print(env.obs_space) #print(env.action_space) #exit() model_params = { "weight initialization scheme": "Normal", "grad": False, "in features": 5, "number of outputs": 1, "min action 1": -1., "max action 1": 1., "noise limit": 0.05 } model = model_factory.make_model("SAR model", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 1., "tolerance": 0.01, "max steps": 256, "memory size": 35 } alg = algorithm_factory.make_alg("sar", model, alg_params) slv_params = {"environment": env, "algorithm": alg} slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem #slv.solve(iterations=1000, ep_len=2000) #slv.solve_online(iterations=1000) slv.solve_online_render(iterations=1000, ep_len=15000) #slv.solve_aggregator(iterations=500, reps=10, ep_len=150) #slv.solve_averager(iterations=1000, reps=10, ep_len=300) slv.demonstrate_env(episodes=3, ep_len=1000)
def main(): # Variable definition precision = torch.float module = "MountainCar-v0" # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": True, "Discrete": True, "module name": module } env = env_factory.make_env("openai", "control", env_params) #print(env.obs_space) #print(env.obs_space.high) #print(env.obs_space.low) #print(env.action_space) #print(env.action_space.high) #print(env.action_space.low) #exit() model_params = { "precision": precision, "weight initialization scheme": "He", "grad": False, "in features": 2, "number of outputs": 3 } model = model_factory.make_model("Roboschool Simple FC", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, "tolerance": 0.01, "max steps": 64, "memory size": 10 } alg = algorithm_factory.make_alg("local search", model, alg_params) slv_params = {"environment": env, "algorithm": alg} slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem slv.solve(iterations=500, ep_len=200) #slv.solve_online(iterations=1000) #slv.solve_online_render(iterations=1000, ep_len=15000) #slv.solve_aggregator(iterations=500, reps=10, ep_len=150) #slv.solve_averager(iterations=1250, reps=1, ep_len=500) slv.demonstrate_env(episodes=3, ep_len=200) slv.save_elite_weights(alg.model, path='', name='mountain_car')
def main(): # Variable definition precision = torch.float #game = "Pong-v0" #game = "Pong-ram-v0" #module = "RoboschoolReacher-v1" module = "RoboschoolAnt-v1" #module = "RoboschoolAtlasForwardWalk-v1" #module = 'RoboschoolInvertedPendulum-v1' # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": False, "module name": module } env = env_factory.make_env("openai", "roboschool", env_params) #print(env.obs_space) #print(env.action_space) #exit() model_params = { "precision": precision, "weight initialization scheme": "Normal", "grad": False, "in features": 28, "number of outputs": 8 } model = model_factory.make_model("Roboschool FC", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, "tolerance": 0.01, "max steps": 64, "memory size": 10 } alg = algorithm_factory.make_alg("local search", model, alg_params) slv_params = {"environment": env, "algorithm": alg} slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem #slv.solve(iterations=1000, ep_len=2000) #slv.solve_online(iterations=1000) slv.solve_online_render(iterations=1000, ep_len=15000) #slv.solve_aggregator(iterations=500, reps=10, ep_len=150) #slv.solve_averager(iterations=1000, reps=10, ep_len=300) slv.demonstrate_env(episodes=3, ep_len=1000)
def main(): # Variable definition precision = torch.float #game = "Pong-v0" game = "Pong-ram-v0" #game = "MsPacman-ram-v0" # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": False, "RAM": True, "game name": game } env = env_factory.make_env("openai", "atari", env_params) model_params = { "precision": precision, "weight initialization scheme": "He", "grad": False, "number of outputs": env.action_space.n, "w": 210, "h": 160, "in features": 128, "in channels": 3 } model = model_factory.make_model("DQN RAM3 model", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "tolerance": 0.01, "minimum entropy": 0.1, "max steps": 50, "memory size": 10 } alg = algorithm_factory.make_alg("neuro2", model, alg_params) slv_params = { "environment": env, "algorithm": alg } slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem slv.solve(iterations=50) slv.demonstrate_env()
def main(): precision = torch.half data_path = "C:/Users/aaa2cn/Documents/fashion_mnist_data" #data_path = "~/Documents/ahmed/fashion_mnist_data" #data_path = "~/Documents/ahmed/cifar10_data" # Make an MNIST Dataset environment env_params = { "data path": data_path, "precision": precision, "score type": "loss", "loss type": "CE loss", "normalize": True, "batch size": 5000, # Entire set, "device": 'cuda' } env = env_factory.make_env("dataset", "fashion mnist", env_params) # Make a pool model_params = { "precision": precision, "weight initialization scheme": "He", "device": 'cuda' } model = model_factory.make_model("FashionMNIST CNN", model_params) #model = models.resnet18(num_classes=10).half().cuda() # Make an algorithm --algorithm takes control of the pool-- alg_params = { "target": env.target, "minimization mode": env.minimize, "tolerance": 0.01, "minimum entropy": -0.1, "max steps": 50, "device": 'cuda' } alg = algorithm_factory.make_alg("local search", model, alg_params) slv_params = { "environment": env, "algorithm": alg, "logger": None } slv = solver_factory.make_slv("dataset", slv_params) # Use solver to solve the problem slv.train_dataset_with_validation(iterations=1000)
def main(): precision = torch.half pool_size = 50 # Make an MNIST Dataset environment env_params = { "data path": "~/Documents/ahmed/mnist_data", "precision": precision, "score type": "accuracy", "loss type": "NLL loss", "batch size": 2000 # Entire set } env = env_factory.make_env("dataset", "mnist", env_params) # Make a pool model_params = { "pool size": pool_size, "precision": precision, "weight initialization scheme": "Default" # Xavier Normal } pool = model_factory.make_pool("MNIST CNN MSN", model_params) # Make an algorithm --algorithm takes control of the pool-- alg_params = { "pool size": pool_size, "number of anchors": 3, "number of probes per anchor": 13, "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, # Percentage "minimum distance": 1000, "patience": 20, "tolerance": 0.01, "learning rate": 0.02, "lambda": 5, "step size": 0.02 } alg = algorithm_factory.make_alg("MSN", pool, alg_params) # Make a solver slv = Solver(env, alg) # Use solver to solve the problem slv.train_dataset_with_validation(iterations=500)
def main(): # Variable definition precision = torch.half game = "MsPacman" # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": False, "RAM": False } env = env_factory.make_env("openai", game, env_params) model_params = { "precision": precision, "weight initialization scheme": "Default", "number of outputs": env.action_space.n, "w": 210, "h": 160, "in features": 128, "in channels": 3 } model = model_factory.make_model("DQN model", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, "tolerance": 0.01, "learning rate": 0.2, "lambda": 5, "alpha": 0.0005, "beta": 0.29, "max steps": 50 } alg = algorithm_factory.make_alg("learner3", model, alg_params) slv_params = {"environment": env, "algorithm": alg} slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem slv.solve_env(iterations=500) slv.demonstrate_env()
def main(): precision = torch.float # Make a function environment function = "rastrigin" env_params = { "data path": "function_data/" + function + "/", "precision": precision, "plot": False, "score type": "error" # Function evaluation } env = env_factory.make_env("function", function, env_params) # Make a pool model_params = { "pool size": 50, "precision": precision, "weight initialization scheme": "Identical" } pool = model_factory.make_pool("Function FC model", model_params) # Make an algorithm --algorithm needs to take charge of the pool-- alg_params = { "pool size": 50, "number of anchors": 4, "number of probes per anchor": 9, "target": env.target, "minimization mode": env.minimize, "minimum distance": 430, "patience": 25, "tolerance": 0.12, "learning rate": 0.05, "lambda": 5, "step size": 0.02 } alg = algorithm_factory.make_alg("MSN2", pool, alg_params) # Make a solver using the environment and algorithm objects slv = Solver(env, alg) # Use solver to solve the problem slv.solve_and_plot(iterations=500)
def main(): precision = torch.half #data_path = "C:/Users/aaa2cn/Documents/fashion_mnist_data" data_path = "~/Documents/ahmed/cifar10_data" # Make an MNIST Dataset environment env_params = { "data path": data_path, "precision": precision, "score type": "accuracy", "loss type": "NLL loss", "batch size": 5000 # Entire set } env = env_factory.make_env("dataset", "cifar10", env_params) # Make a pool model_params = { "precision": precision, "weight initialization scheme": "Spiking" # Xavier Normal } model = model_factory.make_model("CIFAR10 CNN", model_params) # Make an algorithm --algorithm takes control of the pool-- alg_params = { "target": env.target, "minimization mode": env.minimize, "tolerance": 0.01, "minimum entropy": 0.1, "max steps": 100, "memory size": 100 } alg = algorithm_factory.make_alg("spiking1", model, alg_params) slv_params = {"environment": env, "algorithm": alg} slv = solver_factory.make_slv("dataset", slv_params) # Use solver to solve the problem slv.train_dataset_with_validation(iterations=15000)
def main(): # Variable definition precision = torch.float module = "Acrobot-v1" # Max score is -60.0 # Parameter and Object declarations env_params = { "score type": "score", # Function evaluation "render": True, "Discrete": True, "module name": module } env = env_factory.make_env("openai", "control", env_params) #print(env.obs_space) #print(env.obs_space.high) #print(env.obs_space.low) #print(env.action_space) #print(env.action_space.high) #print(env.action_space.low) #exit() model_params = { "precision": precision, "weight initialization scheme": "He", "grad": False, "in features": 6, "number of outputs": 3 } model = model_factory.make_model("Roboschool Simple FC", model_params) alg_params = { "target": env.target, "minimization mode": env.minimize, "minimum entropy": 0.1, "tolerance": 0.01, "max steps": 64, "memory size": 10 } alg = algorithm_factory.make_alg("random search", model, alg_params) experiment = Experiment(api_key="5xNPTUDWzZVquzn8R9oEFkUaa", project_name="jeff-trinkle", workspace="aromorin") experiment.set_name("Acrobot RS") hyper_params = { "Algorithm": "RS", "Parameterization": 1000000, "Decay Factor": 0.3, "Directions": 25000, "Search Radius": 0.5 } experiment.log_parameters(hyper_params) slv_params = {"environment": env, "algorithm": alg, "logger": experiment} slv = solver_factory.make_slv("RL", slv_params) # Use solver to solve the problem slv.solve(iterations=500, ep_len=500) #slv.solve_online(iterations=1000) #slv.solve_online_render(iterations=1000, ep_len=15000) #slv.solve_aggregator(iterations=500, reps=10, ep_len=150) #slv.solve_averager(iterations=250, reps=10, ep_len=500) slv.demonstrate_env(episodes=3, ep_len=500) slv.save_elite_weights(alg.model, path='', name='acrobot')