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')
