self.odom_x += dx * math.cos(self.odom_yaw) - dy * math.sin(
self.odom_yaw)
self.odom_y += dx * math.sin(self.odom_yaw) + dy * math.cos(
self.odom_yaw)
#Submit
submit_prediction([self.odom_x, self.odom_y])
##################结束#################################
# 第一项任务和第二项任务无需修改以下代码
# 仅在第三项任务中需要修改下面的代码
#get teleop data
wheel_torque = self.teleop.getControlInput()
#Output control signals
set_control_input(
{"wheels": [{
"torque": wheel_torque[i]
} for i in range(4)]})
##################结束#################################
app = QApplication([])
player = TrajectoryPlayer(
TRAJECTORY_FILE) if MODE == "trajectory" else TeleOp()
controller = Controller(player)
simulator = Simulator(controller)
startRenderer(app, simulator, size=(1280, 720)) #可传入size参数调整GUI的大小
options['SARSA']['burnInTime'] = options['runTime']['learningRandomTime']/2.0
# # setup the training time
options['runTime']['supervisedTrainingTime'] = 10
options['runTime']['learningRandomTime'] = 20
options['runTime']['learningEvalTime'] = 10
options['runTime']['defaultControllerTime'] = 10
sim = Simulator(autoInitialize=False, verbose=False)
sim.options = copy.deepcopy(options)
sim.initialize()
sim.run(launchApp=False)
# save it to a file
#sim.saveToFile('test')
#sim.setupPlayback()
# Testing
#
#
#
# # sim2 = Simulator(autoInitialize=False, verbose=False)
#save_pickle(pre_embd_w, 'pre_embd_w.pickle')
#save_pickle(system_acts, 'system_acts.pickle')
pre_embd_w = load_pickle('pre_embd_w.pickle')
opts = {'use_ctx': True, 'use_embd': True, 'use_prev': True, 'use_mask': False}
model = HybridCodeNetwork(len(vocab), args.embd_size, args.hidden_size,
len(system_acts), pre_embd_w, **opts)
if torch.cuda.is_available():
model.cuda()
optimizer = torch.optim.Adadelta(
filter(lambda p: p.requires_grad, model.parameters()))
if args.resume is not None and os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
ckpt = torch.load(args.resume)
start_epoch = ckpt['epoch'] + 1 if 'epoch' in ckpt else args.start_epoch
model.load_state_dict(ckpt['state_dict'])
optimizer.load_state_dict(ckpt['optimizer'])
else:
print("=> no checkpoint found")
user_source = 'example_phrases_dict.pickle'
#user_source = 'simulator_uttrs.pickle'
user_simulator = Simulator(user_source, entities)
if args.test != 1:
train(model, train_data, optimizer, w2i, act2i, args.n_epochs,
args.batch_size)
#simulate_test_dialogs(10, print_simulated_dialog=True)
test(model, test_data, w2i, act2i)
gamma * Y[7] + tau * (Y[5] - Y[8])]
start_infection_n1 = 2 / 50
t = np.arange(0, 365, 1)
asol = 100 * integrate.odeint(solver, [1 - R0, R0, 0,
1, 0, 0,
1, 0, 0], t)
plt.plot(t, asol[:, 1], ls='-', color='black', alpha=0.8, lw=2)
plt.plot(t, asol[:, 4], ls='-', color='black', alpha=0.8, lw=2)
ptrue, = plt.plot(t, asol[:, 7], ls='-', color='black', alpha=0.8, lw=2)
for i in range(0, 10):
state = State(regions, routes, verbose=True)
state.set_outbreak('Region 0', R0 * N)
sim = Simulator(state, transfer_prob=tau, beta=beta, gamma=gamma, verbose=True)
solution = np.zeros((365+1, 9))
for i, state in enumerate(sim.run(iterations=365)):
print(i)
for region_id, sir in state.region_sir.items():
print(str(sir))
solution[i, region_id * 3 + 0] = state.region_sir[region_id].susceptible / N
solution[i, region_id * 3 + 1] = state.region_sir[region_id].infected / N
solution[i, region_id * 3 + 2] = state.region_sir[region_id].removed / N
asol = np.asarray(solution) * 100
t = np.arange(0, asol.shape[0])
p1, = plt.plot(t, asol[:, 0], ls='-', color='SteelBlue')
p2, = plt.plot(t, asol[:, 1], ls='-', color='IndianRed')
import sys
sys.path.append("../../src/")
sys.path.append("dist_activity_citylayout/activity_tracking/")
from trafficModels import *
from generated_city import City
from simulator import Simulator
import time
if __name__ == '__main__':
city = City()
from mpi4py import MPI
if MPI.COMM_WORLD.Get_size() == 1:
city.setLocation(0, force=True)
sim = Simulator(city)
#sim.setVerbose(None)
sim.setStateSaving('custom')
#sim.setMemoization()
sim.setMessageCopy('custom')
sim.setTerminationTime(5000.0)
sim.setSchedulerHeapSet()
sim.setGVTInterval(2)
sim.setActivityRelocatorCustom('relocator', 'CityRelocator')
start = time.time()
sim.simulate()
print('Arrived: ' + str(len(city.collector.state.cars) / 468.0))
print("Simulation time: " + str(time.time() - start))
import matplotlib.pyplot as plt
from model_parameters import ModelParameters
from simulation_data import SimulationData
from simulator import Simulator
# model_parameters_inst trzyma parametry całego ura
model_parameters_inst = ModelParameters()
# simulation_data_inst trzyma parametry symulacji
simulation_data_inst = SimulationData(trajectory_number=2,
trajectory_a_coefficient=2,
trajectory_b_coefficient=4)
# w perform_simulation jest pętla while która ma simulation_data_inst.steps iteracji
simulator_inst = Simulator(simulation_data_inst, model_parameters_inst)
simulator_inst.perform_simulation()
# poniżej tylko sprawdzenie jak ładnie działa
plot1 = plt.figure(1)
plt.subplot(2, 1, 1)
plt.plot(simulation_data_inst.time_vector, simulator_inst.speed_left, 'r')
plt.plot(simulation_data_inst.time_vector, simulator_inst.omega_l, 'b')
plt.subplot(2, 1, 2)
plt.plot(simulation_data_inst.time_vector, simulator_inst.speed_right, 'r')
plt.plot(simulation_data_inst.time_vector, simulator_inst.omega_p, 'b')
plot2 = plt.figure(2)
plt.plot(simulator_inst.qr[:, 0], simulator_inst.qr[:, 1], 'b')
plt.plot(simulator_inst.x, simulator_inst.y, 'r')
plt.show()
def run():
""" Driving function for running the simulation.
Press ESC to close the simulation, or [SPACE] to pause the simulation. """
import os
os.chdir(os.getcwd().rsplit(os.sep, 1)[0])
# agent configurations: basix, Q_learning, optimized Q_learning
#conf = 'basic'
#conf = 'Q_learning'
conf = 'optimized_Q_learning'
##############
# Create the environment
# Flags:
# verbose - set to True to display additional output from the simulation
# num_dummies - discrete number of dummy agents in the environment, default is 100
# grid_size - discrete number of intersections (columns, rows), default is (8, 6)
env = Environment()
##############
# Create the driving agent
# Flags:
# learning - set to True to force the driving agent to use Q-learning
# * epsilon - continuous value for the exploration factor, default is 1
# * alpha - continuous value for the learning rate, default is 0.5
if conf == 'basic':
agent = env.create_agent(LearningAgent, learning=False)
##############
# Follow the driving agent
# Flags:
# enforce_deadline - set to True to enforce a deadline metric
env.set_primary_agent(agent)
env.set_primary_agent(agent, enforce_deadline=True)
##############
# Create the simulation
# Flags:
# update_delay - continuous time (in seconds) between actions, default is 2.0 seconds
# display - set to False to disable the GUI if PyGame is enabled
# log_metrics - set to True to log trial and simulation results to /logs
# optimized - set to True to change the default log file name
sim = Simulator(env,
update_delay=.001,
display=False,
log_metrics=True,
optimized=False)
##############
# Run the simulator
# Flags:
# tolerance - epsilon tolerance before beginning testing, default is 0.05
# n_test - discrete number of testing trials to perform, default is 0
sim.run(n_test=10)
elif conf == 'Q_learning':
agent = env.create_agent(LearningAgent,
learning=True,
epsilon_decay=.05)
env.set_primary_agent(agent, enforce_deadline=True)
sim = Simulator(env,
update_delay=.001,
display=False,
log_metrics=True,
optimized=False)
sim.run(n_test=10)
else:
agent = env.create_agent(LearningAgent,
learning=True,
epsilon=1,
alpha=.4,
epsilon_decay=.0025)
env.set_primary_agent(agent, enforce_deadline=True)
sim = Simulator(env,
update_delay=.001,
display=False,
log_metrics=True,
optimized=True)
sim.run(tolerance=0.01, n_test=30)
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) != 2:
usage()
filename = sys.argv[1]
# Initialize scanner
scanner = Scanner(1, 1, '', '', [], [], False, False, False, False)
# Pass in file name, return list of tokens
tokens = scanner.scan(filename)
tokens.append(('EOF', 0, 0, 0))
# Initialize parser
parser = Parser(tokens, 0)
# Return the AST using tokens
ast = parser.parse()
simulator = Simulator(ast['decorated_nodes'], ast['symtable'] )
instructions = []
for inst in ast['decorated_nodes']:
instructions.append( [inst['instruction'], inst['value']] )
print "\n"
print "[Simulator]: Generated instructions for stack machine"
print "\n"
ip = 0
for inst in instructions:
if ip > 9:
print "I" + str(ip) + ": " + str(instructions[ip])
else:
print "I" + str(ip) + ": " + str(instructions[ip])
ip += 1
print "\n"
def __init__(self, plot):
self.abs_path = os.path.dirname(os.path.abspath(__file__))
""" Reading the config """
warnings.filterwarnings("ignore")
self.init_serializer()
config = self.serializer.read_config("config_mpc.yaml",
path=self.abs_path)
self.set_params(config)
if self.seed < 0:
"""
Generate a random seed that will be stored
"""
self.seed = np.random.randint(0, 4294967295)
np.random.seed(self.seed)
logging_level = logging.WARN
if config['verbose']:
logging_level = logging.DEBUG
logging.basicConfig(format='%(levelname)s: %(message)s',
level=logging_level)
np.set_printoptions(precision=16)
dir = self.abs_path + "/stats/mpc"
tmp_dir = self.abs_path + "/tmp/mpc"
self.utils = Utils()
if not self.init_robot(self.robot_file):
logging.error("MPC: Couldn't initialize robot")
return
if not self.setup_scene(self.environment_file, self.robot):
return
#self.run_viewer(self.robot_file, self.environment_file)
self.clear_stats(dir)
logging.info("Start up simulator")
sim = Simulator()
path_evaluator = PathEvaluator()
path_planner = PathPlanningInterface()
logging.info("MPC: Generating goal states...")
goal_states = get_goal_states(
"mpc", self.abs_path, self.serializer, self.obstacles, self.robot,
self.max_velocity, self.delta_t, self.start_state,
self.goal_position, self.goal_radius, self.planning_algortihm,
self.path_timeout, self.num_generated_goal_states,
self.continuous_collision, self.environment_file, self.num_cores)
if len(goal_states) == 0:
logging.error(
"MPC: Couldn't generate any goal states. Problem seems to be infeasible"
)
return
logging.info("MPC: Generated " + str(len(goal_states)) +
" goal states")
sim.setup_reward_function(self.discount_factor, self.step_penalty,
self.illegal_move_penalty, self.exit_reward)
path_planner.setup(self.robot, self.obstacles, self.max_velocity,
self.delta_t, self.use_linear_path,
self.planning_algortihm, self.path_timeout,
self.continuous_collision, self.num_cores)
if self.dynamic_problem:
path_planner.setup_dynamic_problem(
self.robot_file, self.environment_file,
self.simulation_step_size, self.num_control_samples,
self.min_control_duration, self.max_control_duration,
self.add_intermediate_states, self.rrt_goal_bias,
self.control_sampler)
A, H, B, V, W, C, D, M_base, N_base = self.problem_setup(
self.delta_t, self.robot_dof)
time_to_generate_paths = 0.0
if check_positive_definite([C, D]):
m_covs = None
if self.inc_covariance == "process":
m_covs = np.linspace(self.min_process_covariance,
self.max_process_covariance,
self.covariance_steps)
elif self.inc_covariance == "observation":
m_covs = np.linspace(self.min_observation_covariance,
self.max_observation_covariance,
self.covariance_steps)
for j in xrange(len(m_covs)):
M = None
N = None
if self.inc_covariance == "process":
""" The process noise covariance matrix """
M = self.calc_covariance_value(self.robot, m_covs[j], M_base)
#M = m_covs[j] * M_base
""" The observation error covariance matrix """
N = self.calc_covariance_value(self.robot,
self.min_observation_covariance,
N_base,
covariance_type='observation')
elif self.inc_covariance == "observation":
M = self.calc_covariance_value(self.robot,
self.min_process_covariance,
M_base)
N = self.calc_covariance_value(self.robot,
m_covs[j],
N_base,
covariance_type='observation')
P_t = np.array([[0.0 for k in xrange(2 * self.robot_dof)]
for l in xrange(2 * self.robot_dof)])
path_planner.setup_path_evaluator(
A, B, C, D, H, M, N, V, W, self.robot, self.sample_size,
self.obstacles, self.goal_position, self.goal_radius,
self.robot_file, self.environment_file)
sim.setup_problem(A, B, C, D, H, V, W, M, N, self.robot,
self.enforce_control_constraints, self.obstacles,
self.goal_position, self.goal_radius,
self.max_velocity, self.show_viewer_simulation,
self.robot_file, self.environment_file)
sim.set_stop_when_colliding(self.replan_when_colliding)
if self.dynamic_problem:
path_evaluator.setup_dynamic_problem()
sim.setup_dynamic_problem(self.simulation_step_size)
path_planner.setup_reward_function(self.step_penalty,
self.exit_reward,
self.illegal_move_penalty,
self.discount_factor)
mean_number_planning_steps = 0.0
number_of_steps = 0.0
mean_planning_time = 0.0
num_generated_paths_run = 0.0
successful_runs = 0
num_collisions = 0.0
final_states = []
rewards_cov = []
for k in xrange(self.num_simulation_runs):
print "MPC: Run " + str(k + 1)
self.serializer.write_line("log.log", tmp_dir,
"RUN #" + str(k + 1) + " \n")
current_step = 0
x_true = self.start_state
x_estimate = self.start_state
x_tilde_linear = np.array(
[0.0 for i in xrange(2 * self.robot_dof)])
P_t = np.array([[0.0 for i in xrange(2 * self.robot_dof)]
for i in xrange(2 * self.robot_dof)])
deviation_covariance = np.array(
[[0.0 for i in xrange(2 * self.robot_dof)]
for i in xrange(2 * self.robot_dof)])
estimated_deviation_covariance = np.array(
[[0.0 for i in xrange(2 * self.robot_dof)]
for i in xrange(2 * self.robot_dof)])
total_reward = 0.0
terminal = False
while current_step < self.max_num_steps and not terminal:
path_planner.set_start_and_goal(x_estimate, goal_states,
self.goal_position,
self.goal_radius)
t0 = time.time()
(xs, us, zs, control_durations, num_generated_paths,
best_val, state_covariances, deviation_covariances,
estimated_deviation_covariances, mean_gen_times,
mean_eval_times, total_gen_times,
total_eval_times) = path_planner.plan_and_evaluate_paths(
self.num_paths, 0, current_step,
self.evaluation_horizon, P_t, deviation_covariance,
estimated_deviation_covariance, self.timeout)
mean_planning_time += time.time() - t0
mean_number_planning_steps += 1.0
num_generated_paths_run += num_generated_paths
if len(xs) == 0:
logging.error(
"MPC: Couldn't find any paths from start state" +
str(x_estimate) + " to goal states")
total_reward = np.array([-self.illegal_move_penalty
])[0]
current_step += 1
break
x_tilde = np.array(
[0.0 for i in xrange(2 * self.robot_dof)])
n_steps = self.num_execution_steps
if n_steps > len(xs) - 1:
n_steps = len(xs) - 1
if current_step + n_steps > self.max_num_steps:
n_steps = self.max_num_steps - current_step
(x_true, x_tilde, x_tilde_linear, x_estimate, P_t,
current_step, total_reward, terminal, estimated_s,
estimated_c, history_entries) = sim.simulate_n_steps(
xs,
us,
zs,
control_durations,
x_true,
x_tilde,
x_tilde_linear,
x_estimate,
P_t,
total_reward,
current_step,
n_steps,
0.0,
0.0,
max_num_steps=self.max_num_steps)
#print "len(hist) " + str(len(history_entries))
#print "len(deviation_covariances) " + str(len(deviation_covariances))
#print "len(estimated_deviation_covariances) " + str(len(estimated_deviation_covariances))
deviation_covariance = deviation_covariances[
len(history_entries) - 1]
estimated_deviation_covariance = estimated_deviation_covariances[
len(history_entries) - 1]
if (current_step == self.max_num_steps) or terminal:
final_states.append(history_entries[-1].x_true)
print "len " + str(len(history_entries))
print "t " + str(history_entries[-1].t)
if terminal:
successful_runs += 1
history_entries[0].set_replanning(True)
for l in xrange(len(history_entries)):
history_entries[l].set_estimated_covariance(
state_covariances[l])
history_entries[l].serialize(tmp_dir, "log.log")
if history_entries[l].collided:
num_collisions += 1
collided = True
#logging.warn("MPC: Execution finished. True state is " + str(x_true))
#logging.warn("MPC: Estimated state is " + str(x_estimate))
logging.warn("MPC: Executed " + str(current_step) +
" steps")
logging.warn("MPC: terminal " + str(terminal))
if terminal:
print "MPC: Final state: " + str(x_true)
rewards_cov.append(total_reward)
self.serializer.write_line(
"log.log", tmp_dir, "Reward: " + str(total_reward) + " \n")
self.serializer.write_line("log.log", tmp_dir, "\n")
number_of_steps += current_step
mean_planning_time_per_step = mean_planning_time / mean_number_planning_steps
mean_planning_time /= self.num_simulation_runs
""" Calculate the distance to goal area
"""
ee_position_distances = []
for state in final_states:
joint_angles = v_double()
joint_angles[:] = [state[y] for y in xrange(len(state) / 2)]
ee_position = v_double()
self.robot.getEndEffectorPosition(joint_angles, ee_position)
ee_position = np.array(
[ee_position[y] for y in xrange(len(ee_position))])
dist = np.linalg.norm(
np.array(self.goal_position - ee_position))
if dist < self.goal_radius:
dist = 0.0
ee_position_distances.append(dist)
logging.info("MPC: Done. total_reward is " + str(total_reward))
try:
n, min_max, mean_distance_to_goal, var, skew, kurt = scipy.stats.describe(
np.array(ee_position_distances))
except:
print ee_position_distances
sleep
self.serializer.write_line("log.log", tmp_dir,
"################################# \n")
self.serializer.write_line(
"log.log", tmp_dir,
"inc_covariance: " + str(self.inc_covariance) + "\n")
if self.inc_covariance == "process":
self.serializer.write_line(
"log.log", tmp_dir,
"Process covariance: " + str(m_covs[j]) + " \n")
self.serializer.write_line(
"log.log", tmp_dir, "Observation covariance: " +
str(self.min_observation_covariance) + " \n")
elif self.inc_covariance == "observation":
self.serializer.write_line(
"log.log", tmp_dir, "Process covariance: " +
str(self.min_process_covariance) + " \n")
self.serializer.write_line(
"log.log", tmp_dir,
"Observation covariance: " + str(m_covs[j]) + " \n")
number_of_steps /= self.num_simulation_runs
self.serializer.write_line(
"log.log", tmp_dir,
"Mean number of steps: " + str(number_of_steps) + " \n")
self.serializer.write_line(
"log.log", tmp_dir, "Mean num collisions per run: " +
str(float(num_collisions) / float(self.num_simulation_runs)) +
" \n")
self.serializer.write_line(
"log.log", tmp_dir, "Average distance to goal area: " +
str(mean_distance_to_goal) + " \n")
self.serializer.write_line(
"log.log", tmp_dir,
"Num successes: " + str(successful_runs) + " \n")
print "succ " + str(
(100.0 / self.num_simulation_runs) * successful_runs)
self.serializer.write_line(
"log.log", tmp_dir, "Percentage of successful runs: " + str(
(100.0 / self.num_simulation_runs) * successful_runs) +
" \n")
self.serializer.write_line(
"log.log", tmp_dir, "Mean planning time per run: " +
str(mean_planning_time) + " \n")
self.serializer.write_line(
"log.log", tmp_dir, "Mean planning time per planning step: " +
str(mean_planning_time_per_step) + " \n")
n, min_max, mean, var, skew, kurt = scipy.stats.describe(
np.array(rewards_cov))
print "mean_rewards " + str(mean)
#plt.plot_histogram_from_data(rewards_cov)
#sleep
self.serializer.write_line("log.log", tmp_dir,
"Mean rewards: " + str(mean) + " \n")
self.serializer.write_line("log.log", tmp_dir,
"Reward variance: " + str(var) + " \n")
self.serializer.write_line(
"log.log", tmp_dir,
"Reward standard deviation: " + str(np.sqrt(var)) + " \n")
self.serializer.write_line("log.log", tmp_dir,
"Seed: " + str(self.seed) + " \n")
cmd = "mv " + tmp_dir + "/log.log " + dir + "/log_mpc_" + str(
m_covs[j]) + ".log"
os.system(cmd)
cmd = "cp " + self.abs_path + "/config_mpc.yaml " + dir
os.system(cmd)
if not os.path.exists(dir + "/environment"):
os.makedirs(dir + "/environment")
cmd = "cp " + self.abs_path + "/" + str(
self.environment_file) + " " + str(dir) + "/environment"
os.system(cmd)
if not os.path.exists(dir + "/model"):
os.makedirs(dir + "/model")
cmd = "cp " + self.abs_path + "/" + self.robot_file + " " + dir + "/model"
os.system(cmd)
print "Done."
def run():
isOptimized = True
isLearning = True
dict_name = 'Q_learned_dict'
dict_name_pikle = 'Q_learned_dict.pkl'
def load_dict():
with open(dict_name + '.pkl', 'rb') as f:
return pickle.load(f)
def save_dict(obj):
with open(dict_name + '.pkl', 'wb') as f:
pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
""" Driving function for running the simulation.
Press ESC to close the simulation, or [SPACE] to pause the simulation. """
##############
# Create the environment
# Flags:
# verbose - set to True to display additional output from the simulation
# num_dummies - discrete number of dummy agents in the environment, default is 100
# grid_size - discrete number of intersections (columns, rows), default is (8, 6)
env = Environment()
##############
# Create the driving agent
# Flags:
# * learning - set to True to force the driving agent to use Q-learning
# * epsilon - continuous value for the exploration factor, default is 1
# * alpha - continuous value for the learning rate, default is 0.5
Q_dict = {}
if (isLearning and os.path.isfile(dict_name_pikle) and isOptimized):
print('inside_if_condition')
Q_dict = load_dict()
print(len(Q_dict))
l = LearningAgent(env,
learning=isLearning,
alpha=0.6,
epsilon=0.20,
dictn=Q_dict)
agent = env.create_agent_new(
l) #, learning=True, alpha=0.5, epsilon=0.015)
##############
# Follow the driving agent
# Flags:
# enforce_deadline - set to True to enforce a deadline metric
env.set_primary_agent(agent, enforce_deadline=True)
##############
# Create the simulation
# Flags:
# update_delay - continuous time (in seconds) between actions, default is 2.0 seconds
# display - set to False to disable the GUI if PyGame is enabled
# log_metrics - set to True to log trial and simulation results to /logs
# optimized - set to True to change the default log file name
sim = Simulator(env,
update_delay=0.01,
log_metrics=True,
optimized=isOptimized,
display=False)
##############
# Run the simulator
# Flags:
# tolerance - epsilon tolerance before beginning testing, default is 0.05
# n_test - discrete number of testing trials to perform, default is 0
sim.run(n_test=50, tolerance=0.01)
new_dict = LearningAgent.printDict(l)
if (isLearning and (not isOptimized)):
save_dict(new_dict)
print('Directory Saved')
import unittest
from pfobjects import Cluster, SmearedCluster
from detectors.CMS import cms
from simulator import Simulator
from ROOT import TVector3
import math
import numpy as np
from ROOT import TFile, TH1F, TH2F
simulator = Simulator(cms)
class TestCluster(unittest.TestCase):
def test_pt(self):
'''Test that pT is correctly set.'''
cluster = Cluster(10., TVector3(1,0,0), 1, 1)
self.assertAlmostEqual(cluster.pt, 10.)
cluster.set_energy(5.)
self.assertAlmostEqual(cluster.pt, 5.)
def test_smear(self):
rootfile = TFile('test_cluster_smear.root', 'recreate')
h_e = TH1F('h_e','cluster energy', 200, 5, 15.)
energy = 10.
cluster = Cluster(energy, TVector3(1,0,0), 1, 1)
ecal = cms.elements['ecal']
energies = []
for i in range(10000):
smeared = simulator.smear_cluster(cluster, ecal, accept=True)
h_e.Fill(smeared.energy)
energies.append(smeared.energy)
import glob
import os
import simulator as s
from simulator import Simulator
from time import sleep
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
if __name__ == '__main__':
GUI = False
sim = Simulator(gui=GUI, g=-10, debug=False, epochs=240)
sim.restore( '/home/mario/data/scenes/0_136ef91c95ca5c2d4b9a4e1a888c5f59_scene.csv', os.environ['MODELS_PATH'])
cam = s.Camera(width=900, height=900,pos=[-0.75, -0.75, 1],target=[0.5, 0.5,0], far=6,up=[1., 1., 0.], fov=60)
rgb,depth = cam.snap()
plt.imshow(rgb)
plt.show()
exit()
#sim.load('cube_small.urdf', pos=[0.2, 0.5,0.025])
#sim.cam.target = [0.2, 0.5, 0.0]
#sim.cam.project(sim.cam.target)
#rgb,depth = sim.cam.snap()
#if not GUI:
# plt.imshow(depth)
# plt.show()
#u = 146
#v = 151
#d = depth[v, u]
##u = 201
##v = 155
from trafficLightModel_classic import *
# ======================================================================
# 1. Instantiate the (Coupled or Atomic) DEVS at the root of the
# hierarchical model. This effectively instantiates the whole model
# thanks to the recursion in the DEVS model constructors (__init__).
#
trafficSystem = TrafficSystem(name="trafficSystem")
# ======================================================================
# 2. Link the model to a DEVS Simulator:
# i.e., create an instance of the 'Simulator' class,
# using the model as a parameter.
sim = Simulator(trafficSystem)
# ======================================================================
# 3. Perform all necessary configurations, the most commonly used are:
# A. Termination time (or termination condition)
# Using a termination condition will execute a provided function at
# every simulation step, making it possible to check for certain states
# being reached.
# It should return True to stop simulation, or Falso to continue.
def terminate_whenStateIsReached(clock, model):
return model.trafficLight.state.get() == "manual"
def __init__(self, p=2.0/3): self.sim = Simulator(p) self.start_state = State (-1, -1, -1)
def optimize(self):
optimizer = Optimizer(self.plant, self.orderList,
Simulator(self.plant), Evaluator(self.plant))
result = optimizer.run()
print bestSolution(result)
LOW = 0
UP = 119
params = {
"crossover": {
"operator": tools.cxTwoPoint
},
"mutate": {
"operator": tools.mutShuffleIndexes,
"indpb": 0.1
},
"select": {
"operator": tools.selBest,
"k": int(math.sqrt(NUM_INDIVIDUALS // 2))
},
"populationGA1": None,
"numGeneration1": 10,
"numGeneration2": 3,
"crossroads": 21,
"timeSteps": 2,
"numIndividuals1": NUM_INDIVIDUALS,
"numIndividuals2": 10,
"simulator": Simulator(10, 2, 3),
"fitnessGA1": "1",
"fitnessGA2": "1",
"minLim": LOW,
"maxLim": UP
}
controller = Controller(params)
print(controller.run1())
# it does not have to do anything other than be imported.
from util import path
from examples.minimalExample.SimulatorCrownstone import SimulatorCrownstone
from simulator import SimulationGui, JsonFileStore, Simulator
config = JsonFileStore('./minimalExample/config.json').getData()
userModule = JsonFileStore('./minimalExample/userData.json').getData()
root = SimulatorCrownstone(1, 0, 0)
root.root = True
simulatorCrownstones = [
root,
SimulatorCrownstone(2, 5, 3),
SimulatorCrownstone(3, 10, 6),
SimulatorCrownstone(4, 15, 9),
SimulatorCrownstone(5, 15, 13),
]
a = SimulationGui()
a.loadSimulatorCrownstones(simulatorCrownstones)
a.loadConfig(config)
b = Simulator()
b.loadCrownstones(simulatorCrownstones)
b.loadConfig(config)
a.loadSimulator(
b) # this will load the user module into the simulator as a broadcaster.
a.startSimulation(2)
#a.run()
default=10000,
type=int,
help="Define a janela de busca pelo fim do período transiente")
parser.add_argument(
"-a",
"--alpha",
default=0.05,
type=float,
help="Define o alpha (para cálculo do intervalo de confiança)")
parser.add_argument(
"-s",
"--seed",
default=None,
type=float,
help=
"Define a semente para o gerador de números aleatórios que alimenta as chegadas de fregueses e o tempo de serviço"
)
args = parser.parse_args()
simulations = []
for i in range(args.rounds):
simulator = Simulator(args.use, args.events, i, args.transienterror,
args.window, args.seed)
simulations.append(simulator)
ret = simulator.start()
if not ret:
break
# Calcular intervalo de confiança
from matplotlib import animation
from tqdm import tqdm
import matplotlib.pyplot as plt
from simulator import Simulator
from core import World
from viz import show_picture
ITERS = 100
sim = Simulator()
# First set up the figure, the axis, and the plot element we want to animate
fig, ax = plt.subplots()
pbar = tqdm(total=ITERS)
# animation function. This is called sequentially
def animate(i):
ax.cla()
img = show_picture(sim.world, [actor.ant for actor in sim.actors])
sim.iterate()
pbar.update(1)
im = ax.imshow(img)
return im,
anim = animation.FuncAnimation(fig,
animate,
frames=ITERS,
def run():
"""Run the agent for a finite number of trials."""
import time
alpha_range = [x / 100.0 for x in range(1, 21)]
gamma_range = [x / 100.0 for x in range(1, 21)]
max_result = 0
best_alpha = 0
best_gamma = 0
timestr = time.strftime("%Y%m%d-%H%M%S")
filename = 'gridsearch_' + timestr + '.log'
with open(filename, 'a') as logfile:
logfile.write(
"Alpha,Gamma,SuccessRate,Last20RedLightViolations,Last20PlannerNoncompliance\n"
)
for alpha in alpha_range:
for gamma in gamma_range:
success_rates = []
last20_redlight_violations = []
last20_planner_noncompliance = []
for count in range(10):
# Set up environment and agent
e = Environment(
) # create environment (also adds some dummy traffic)
a = e.create_agent(LearningAgent) # create agent
a.gamma = gamma
a.alpha = alpha
e.set_primary_agent(
a, enforce_deadline=True) # specify agent to track
# NOTE: You can set enforce_deadline=False while debugging to allow longer trials
# Now simulate it
sim = Simulator(
e, update_delay=0.0000005, display=False
) # create simulator (uses pygame when display=True, if available)
# NOTE: To speed up simulation, reduce update_delay and/or set display=False
sim.run(n_trials=100) # run for a specified number of trials
# NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line
#plot_agent_performance(a.alpha, a.gamma,a.success_rate, a.red_light_violations, a.planner_noncompliance, count)
sum_last20_redlight_violations = sum(
a.red_light_violations[-20:])
sum_last20_planner_noncompliance = sum(
a.planner_noncompliance[-20:])
success_rates.append(a.success_rate)
last20_redlight_violations.append(
sum_last20_redlight_violations)
last20_planner_noncompliance.append(
sum_last20_planner_noncompliance)
mean_success = sum(success_rates) / float(len(success_rates))
mean_last20redlight = sum(last20_redlight_violations) / float(
len(last20_redlight_violations))
mean_last20planner = sum(last20_planner_noncompliance) / float(
len(last20_planner_noncompliance))
print 'Mean success rate: ', mean_success
print 'Mean last 20 red light violationse: ', mean_last20redlight
print 'Mean last 20 planner_noncompliance: ', mean_last20planner
with open(filename, 'a') as logfile:
logfile.write("%.2f,%.2f,%d,%.2f,%.2f\n" %
(alpha, gamma, mean_success, mean_last20redlight,
mean_last20planner))
import pickle
from simulator import Simulator
import torch
import torch.nn as nn
from reinforcement.metrics import Metrics
from torch.autograd import Variable
from PolicyGradient import PolicyNetwork
from PolicyGradient import policy
from DQN import DQN
from DQN import DQN_policy
# if gpu is to be used
use_cuda = torch.cuda.is_available()
FloatTensor = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor
LongTensor = torch.cuda.LongTensor if use_cuda else torch.LongTensor
ByteTensor = torch.cuda.ByteTensor if use_cuda else torch.ByteTensor
Tensor = FloatTensor
environment=Simulator()
policy_network = torch.load("saved_policy/REINFORCE.pkl")
model = torch.load("saved_policy/DQN.pkl")
metrics = Metrics(environment)
inc = metrics.compare_policy([("PolicyGradient",policy),("DQN",DQN_policy)], 20, False)
print(inc)
# distribution = "constant"
# distribution = "uniform"
distribution = "exponential"
index = []
hit_ratio = []
load = []
for cachesize in range(50, 501, 25):
index.append(cachesize)
# new_simulator = NewSimulator(cachesize, amount, expected_value, total_rate, z, N, pattern)
# hit_ratio.append(new_simulator.cache.totalHitRatio())
# load.append(new_simulator.cache.totalLoad()/10000.0)
env = simpy.Environment()
simulator = Simulator(env, cachesize, amount, expected_value, total_rate, content, popularity, N, pattern,
distribution).getSimulator()
simulator.setDuration(0.01)
simulator.setDelta(50)
env.process(simulator.updateSim())
env.process(simulator.insertSim())
env.run(until=simulation_time)
hit_ratio.append(simulator.cache.totalHitRatio())
load.append(simulator.cache.totalLoad()/float(simulation_time))
print("simulation: ", simulator.cache.totalHitRatio())
print(cachesize)
print(hit_ratio)
print(load)
# print(hit_ratio_model_proactive_remove)
# print(hit_ratio_model_proactive_renew)
# custom modules
from utils import Options
from simulator import Simulator
from transitionTable import TransitionTable
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# NOTE:
# this script assumes you did generate your data with the get_data.py script
# you are of course allowed to change it and generate data here but if you
# want this to work out of the box first run get_data.py
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# 0. initialization
opt = Options()
sim = Simulator(opt.map_ind, opt.cub_siz, opt.pob_siz, opt.act_num)
trans = TransitionTable(opt.state_siz, opt.act_num, opt.hist_len,
opt.minibatch_size, opt.valid_size, opt.states_fil,
opt.labels_fil)
# 1. train
######################################
# TODO implement your training here!
# you can get the full data from the transition table like this:
#
# # both train_data and valid_data contain tupes of images and labels
# train_data = trans.get_train()
# valid_data = trans.get_valid()
#
# alternatively you can get one random mini batch line this
#
#-----------------------Clear Figures----------------------------
# clear figures
plt.close('all')
#-----------------Configuration / Parameters--------------------
tspan = np.array([0, 100]) # [sec]
L_cmd = np.zeros(3) # initially command 0 torque
#----------------Initialize / Setup Workspace------------------
# setup sim
sim = Simulator(config)
# preallocate memory
T = np.arange(0, tspan[1]+config.tstep, config.tstep)
state_history = np.zeros((np.shape(T)[0], np.shape(sim.state)[0]))
state_history[0, :] = sim.state
B_ECI_history = np.zeros((np.shape(T)[0], 3))
B_body_history = np.zeros((np.shape(T)[0], 3))
command_history = np.zeros((np.shape(T)[0], 3))
#---------------------Propagate---------------------------
t = time.time()
for i, elapsed_t in enumerate(T[0:-1]):
# Simulator
sensors = sim.step(L_cmd)
state_history[i+1, :] = sim.state
z1 = 0
z2 = 3
for _ in range(new_objects):
x1 = np.random.randint(0, 16)
x2 = np.random.randint(0, 16)
y1 = np.random.randint(0, 16)
y2 = np.random.randint(0, 16)
points = np.array([[x1, x1, x2, x2], [y1, y1, y2, y2], [z1, z2, z1, z2]])
objects.append(Obstacle("rectangle", points))
env = Environment()
for o in objects:
env.add_obstacle(o)
if __name__ == "__main__":
c = SwarmController(drones, set_points)
s = Simulator(environment=env,
drones=drones,
controller=c,
com_delay=0.1,
log_to_file="test_0.json",
env_to_file="env_test_0.json")
s.simulate(0.05, 10)
k = Logger()
k.load_from_file("test_0.json")
s = Simulator(logger=k)
s.visualize()
import sys
sys.path.append("../src")
from simulator import Simulator
from model import Cluster
#import stacktracer
#stacktracer.trace_start("trace.html",interval=5,auto=True) # Set auto flag to always update file!
model = Cluster(2)
sim = Simulator(model)
sim.setVerbose(None)
#sim.setTerminationTime(10.0)
sim.setStateSaving("custom")
sim.simulate()
velocity=Vector2(0.05, 0),
mass=50,
draw_radius=5,
color=(0, 255, 0))
b3 = Body(Vector2(0.05, 50),
velocity=Vector2(0, 0.1),
mass=50,
draw_radius=5,
color=(255, 0, 0))
world = World()
world.add(b1)
world.add(b2)
world.add(b3)
simulator = Simulator(world, DummyEngine, RK4)
screen_size = Vector2(800, 600)
screen = Screen(screen_size, bg_color=(0, 0, 0), caption="Simulator")
screen.camera.scale = 1
# this coefficient controls the speed
# of the simulation
time_scale = 10
simulator.solver.max_step_size = time_scale / 100
print("Start program")
while not screen.should_quit:
dt = screen.tick(60)
"type": "LSTM",
"units": 16,
"return_sequences": True
}, {
"type": "LSTM",
"units": 16,
"return_sequences": False
}, {
"type": "Dense",
"units": 16,
"activation": "relu"
}, {
"type": "Dense",
"units": 16,
"activation": "relu"
}]
q_model = Q_Model("GRU",
state_dim=env.get_state().shape,
no_of_actions=env.no_of_actions,
layers=dense_model,
hyperparameters={"lr": 0.0001})
agent = Agent(q_model, batch_size=8, discount_factor=0.8, epsilon=1)
no_of_episodes_train = 100
no_of_episodes_test = 100
sim = Simulator(env, agent)
sim.train(no_of_episodes_train, epsilon_decay=0.997)
agent.model.save()
sim.test(no_of_episodes_test)
# Supressing warnings about time clock being deprecated for higher versions of Python3
import warnings
warnings.filterwarnings("ignore")
from simulator import Simulator
now = time.clock()
# Initialize all the global variables
globals.initialize()
# Create the simulator with the given filename
if (len(sys.argv) < 3):
sys.exit("Please include the input file and run time as arguments.\n example: \
python3 main.py test_case1.json 20")
try:
val = int(sys.argv[2])
except ValueError:
sys.exit("Please enter an integer value in seconds for the runtime")
if (val > 100):
sys.exit("This runtime seems too large. \n Please enter an integer value in seconds (less than 100) for the runtime.")
sim = Simulator(sys.argv[1], val)
print("Starting simulation for", sys.argv[1], ", running for", sys.argv[2], "seconds.")
sim.run()
print("The simulation finished.")
sim.plot_metrics()
end = time.clock()
elapsed = end - now
print("TIME ELAPSED: ")
print(elapsed)
draw_radius=10)
b2 = Body(Vector2(1, 1),
velocity=Vector2(0, 0.2),
mass=5,
color=(240, 128, 128),
draw_radius=5)
world = World()
world.add(b1)
world.add(b2)
listbodies = [b1, b2]
ChoixSolver = KuttaSolver #choix du solveur : Dummy ou Kutta
simulator = Simulator(world, DummyEngine, ChoixSolver)
screen_size = Vector2(800, 600)
screen = Screen(screen_size, bg_color=(0, 0, 0), caption="Simulator")
screen.camera.scale = 10 #pas trop grand sinon on ne voit pas les deux particules
#autour de 10
# this coefficient controls the speed
# of the simulation
time_scale = 10
print("Start program")
while not screen.should_quit:
dt = screen.tick(60)
# simulate physics
delta_time = time_scale * dt / 1000
