def main():
# Get parameters from arguments
parser = argparse.ArgumentParser(description='Model training')
parser.add_argument('-c',
'--config_path',
type=str,
default='./config/diwu_rematch.py',
help='Configuration file')
arguments = parser.parse_args()
assert arguments.config_path is not None, 'Please provide a path using -c config/pathname in the command line'
print('\n > Start Time:')
print(' ' + datetime.now().strftime('%a, %d %b %Y-%m-%d %H:%M:%S'))
start_time = time.time()
# Define the user paths
# Load configuration files
configuration = Configuration(arguments.config_path)
cf = configuration.load()
configurationPATH(cf)
process(cf)
# End Time
end_time = time.time()
print('\n > End Time:')
print(' ' + datetime.now().strftime('%a, %d %b %Y-%m-%d %H:%M:%S'))
print('\n ET: ' + HMS(end_time - start_time))
def main():
# Define environment variables
# Environment()
# Get parameters from arguments
parser = argparse.ArgumentParser(description='Model training')
parser.add_argument('-c',
'--config_path',
type=str,
default=None,
help='Configuration file')
parser.add_argument('-e',
'--exp_name',
type=str,
default=None,
help='Name of the experiment')
parser.add_argument('-s',
'--shared_path',
type=str,
default='/data/module5',
help='Path to shared data folder')
parser.add_argument('-l',
'--local_path',
type=str,
default='/home/master/sufav/results',
help='Path to local data folder')
arguments = parser.parse_args()
assert arguments.config_path is not None, 'Please provide a configuration' \
'path using -c config/pathname' \
' in the command line'
assert arguments.exp_name is not None, 'Please provide a name for the ' \
'experiment using -e name in the ' \
'command line'
# Define the user paths
shared_path = arguments.shared_path
local_path = arguments.local_path
dataset_path = os.path.join(local_path, 'Datasets')
shared_dataset_path = os.path.join(shared_path, 'Datasets')
experiments_path = os.path.join(local_path, getuser(), 'Experiments')
# Note: this should not be used
shared_experiments_path = os.path.join(shared_path, getuser(),
'Experiments')
usr_path = os.path.join('/home/', getuser())
# Load configuration files
configuration = Configuration(arguments.config_path, arguments.exp_name,
dataset_path, shared_dataset_path,
experiments_path, shared_experiments_path,
usr_path)
cf = configuration.load()
# Train /test/predict with the network, depending on the configuration
process(cf)
# Copy result to shared directory
configuration.copy_to_shared()
def main():
print('Using GPU: ', torch.cuda.get_device_name(0))
start_time = time.time()
# Prepare configuration
config = Configuration()
cf = config.load()
# Enable log file
logger_debug = Logger(cf.log_file_debug)
logger_debug.write('\n ---------- Init experiment: ' + cf.exp_name +
' ---------- \n')
# Model building
logger_debug.write('- Building model: ' + cf.model_name + ' <--- ')
model = ModelBuilder(cf)
model.build()
print(model.net)
# Problem type
if cf.problem_type == 'segmentation':
problem_manager = SemanticSegmentationManager(cf, model)
elif cf.problem_type == 'classification':
problem_manager = ClassificationManager(cf, model)
elif cf.problem_type == 'detection':
problem_manager = DetectionManager(cf, model)
else:
raise ValueError('Unknown problem type')
# Create dataloader builder
dataloader = DataLoaderBuilder(cf, model)
if cf.train:
model.net.train() # enable dropout modules and others
train_time = time.time()
logger_debug.write('\n- Reading Train dataset: ')
dataloader.build_train()
if (cf.valid_dataset_path is not None or
(cf.valid_images_txt is not None
and cf.valid_gt_txt is not None)) and cf.valid_samples_epoch != 0:
logger_debug.write('\n- Reading Validation dataset: ')
dataloader.build_valid(cf.valid_samples_epoch, cf.valid_images_txt,
cf.valid_gt_txt, cf.resize_image_valid,
cf.valid_batch_size)
problem_manager.trainer.start(dataloader.train_loader,
dataloader.train_set,
dataloader.valid_set,
dataloader.valid_loader)
else:
# Train without validation inside epoch
problem_manager.trainer.start(dataloader.train_loader,
dataloader.train_set)
train_time = time.time() - train_time
logger_debug.write('\t Train step finished: %ds ' % train_time)
if cf.validation:
model.net.eval()
valid_time = time.time()
if not cf.train:
logger_debug.write('- Reading Validation dataset: ')
dataloader.build_valid(cf.valid_samples, cf.valid_images_txt,
cf.valid_gt_txt, cf.resize_image_valid,
cf.valid_batch_size)
else:
# If the Dataloader for validation was used on train, only update the total number of images to take
dataloader.valid_set.update_indexes(
cf.valid_samples,
valid=True) # valid=True avoids shuffle for validation
logger_debug.write('\n- Starting validation <---')
problem_manager.validator.start(dataloader.valid_set,
dataloader.valid_loader, 'Validation')
valid_time = time.time() - valid_time
logger_debug.write('\t Validation step finished: %ds ' % valid_time)
if cf.test:
model.net.eval()
test_time = time.time()
logger_debug.write('\n- Reading Test dataset: ')
dataloader.build_valid(cf.test_samples, cf.test_images_txt,
cf.test_gt_txt, cf.resize_image_test,
cf.test_batch_size)
logger_debug.write('\n - Starting test <---')
problem_manager.validator.start(dataloader.valid_set,
dataloader.valid_loader, 'Test')
test_time = time.time() - test_time
logger_debug.write('\t Test step finished: %ds ' % test_time)
if cf.predict_test:
model.net.eval()
pred_time = time.time()
logger_debug.write('\n- Reading Prediction dataset: ')
dataloader.build_predict()
logger_debug.write('\n - Generating predictions <---')
problem_manager.predictor.start(dataloader.predict_loader)
pred_time = time.time() - pred_time
logger_debug.write('\t Prediction step finished: %ds ' % pred_time)
total_time = time.time() - start_time
logger_debug.write('\n- Experiment finished: %ds ' % total_time)
logger_debug.write('\n')
def main():
# Define environment variables
# Environment()
# Get parameters from arguments
parser = argparse.ArgumentParser(description='Model training')
parser.add_argument('-c',
'--config_path',
type=str,
default=None,
help='Configuration file')
parser.add_argument('-e',
'--exp_name',
type=str,
default=None,
help='Name of the experiment')
parser.add_argument('-s',
'--shared_path',
type=str,
default='/data',
help='Path to shared data folder')
parser.add_argument('-l',
'--local_path',
type=str,
default='/datatmp',
help='Path to local data folder')
arguments = parser.parse_args()
assert arguments.config_path is not None, 'Please provide a configuration'\
'path using -c config/pathname'\
' in the command line'
assert arguments.exp_name is not None, 'Please provide a name for the '\
'experiment using -e name in the '\
'command line'
# Start Time
print('\n > Start Time:')
print(' ' + datetime.now().strftime('%a, %d %b %Y-%m-%d %H:%M:%S'))
start_time = time.time()
# Define the user paths
shared_path = arguments.shared_path
local_path = arguments.local_path
dataset_path = os.path.join(local_path, 'Datasets')
shared_dataset_path = os.path.join(shared_path, 'Datasets')
experiments_path = os.path.join(local_path, 'Experiments')
shared_experiments_path = os.path.join(shared_path, 'Experiments')
usr_path = os.path.join('/home/', getuser())
# Load configuration files
configuration = Configuration(arguments.config_path, arguments.exp_name,
dataset_path, shared_dataset_path,
experiments_path, shared_experiments_path,
usr_path)
cf = configuration.load()
configurationPATH(cf, dataset_path)
# Train /test/predict with the network, depending on the configuration
process(cf)
# Copy result to shared directory
# configuration.copy_to_shared()
# End Time
end_time = time.time()
print('\n > End Time:')
print(' ' + datetime.now().strftime('%a, %d %b %Y-%m-%d %H:%M:%S'))
print('\n ET: ' + HMS(end_time - start_time)) # -> H:M:S
def main():
# Load configuration files
configuration = Configuration(
'/home/wzn/PycharmProjects/alibaba_weather_route/config/wzn.py')
cf = configuration.load()
# get the original 6*9 maze
time_length = 25
maze = Maze_3D(height=9,
width=9,
time_length=time_length,
start_state=(2, 0, 0),
goal_states=[[0, 8]],
return_to_start=cf.return_to_start,
strong_wind_return=cf.strong_wind_return,
reward_goal=cf.reward_goal,
reward_move=cf.reward_move,
reward_obstacle=cf.reward_obstacle,
cf=cf)
# set up goal states
gs = []
for t in range(time_length):
gs.append(tuple([0, 8, t]))
maze.GOAL_STATES = gs
# set up obstacles
maze.wind_real_day_hour_total = np.zeros(shape=(maze.WORLD_HEIGHT,
maze.WORLD_WIDTH,
maze.TIME_LENGTH))
obstacles = [[1, 2], [2, 2], [3, 2], [0, 7], [1, 7], [2, 7], [4, 5]]
for t in range(time_length - 5):
for item in obstacles:
maze.wind_real_day_hour_total[item[0], item[1], t] = cf.wall_wind
obstacles = [[2, 4], [3, 4], [3, 2], [0, 7], [1, 7], [2, 7], [4, 5]]
for t in range(5, time_length):
for item in obstacles:
maze.wind_real_day_hour_total[item[0], item[1], t] = cf.wall_wind
for t in range(5, time_length - 3):
maze.wind_real_day_hour_total[1, 8, t] = cf.wall_wind
# Dyna model hyper
rand = np.random.RandomState(0)
planningSteps = 5
alpha = 0.5
gamma = 0.99
theta = 1e-4
epsilon = 0.1
# track the # of backups
runs = 1
numOfMazes = 1
numOfModels = 5
backups = np.zeros((runs, numOfModels, numOfMazes))
############## A star search algorithm ######################################
start_time = timer()
diagram = convert_3D_maze_to_grid(maze, cf)
came_from, cost_so_far, [final_goal_time
], wind_costs, rainfall_costs = a_star_search_3D(
diagram, tuple(maze.START_STATE),
maze.GOAL_STATES)
go_to_all, steps = walk_final_grid_go_to(tuple(maze.START_STATE),
maze.GOAL_STATES,
came_from,
final_goal_time,
include_all=cf.include_all)
if True:
draw_grid_3d(diagram,
came_from=came_from,
start=tuple(maze.START_STATE),
goal=tuple(maze.GOAL_STATES),
title='A star')
print('Finish, using %.2f sec!' % (timer() - start_time))
# the following expand dims just to cater to challenge might have 10 models
maze.wind_real_day_hour_total = np.tile(maze.wind_real_day_hour_total,
[10, 1, 1, 1])
# we artificially added this
# for t in range(time_length-2):
# for item in [[0, 2]]:
# maze.wind_real_day_hour_total[cf.temp_model, item[0], item[1], t] = cf.wall_wind
##############End A star search algorithm ######################################
model_Dyna_Q = Dyna_3D(rand=rand,
maze=maze,
epsilon=epsilon,
gamma=gamma,
planningSteps=planningSteps,
qLearning=True,
expected=False,
alpha=alpha,
priority=False)
model_Dyna_Prioritized_Sweeping_ES = Dyna_3D(rand=rand,
maze=maze,
epsilon=epsilon,
gamma=gamma,
planningSteps=planningSteps,
qLearning=False,
expected=True,
alpha=alpha,
priority=True,
theta=theta)
model_Dyna_Prioritized_Sweeping_Q = Dyna_3D(rand=rand,
maze=maze,
epsilon=epsilon,
gamma=gamma,
planningSteps=planningSteps,
qLearning=True,
expected=False,
alpha=alpha,
priority=True,
theta=theta)
model_Dyna_Prioritized_Sweeping_Q_A_star = Dyna_3D(
rand=cf.random_state,
maze=maze,
epsilon=cf.epsilon,
gamma=cf.gamma,
planningSteps=cf.planningSteps,
qLearning=cf.qLearning,
expected=cf.expected,
alpha=cf.alpha,
priority=cf.priority,
theta=cf.theta,
policy_init=go_to_all,
plus=cf.plus,
increase_epsilon=cf.increase_epsilon)
model_Dyna_Prioritized_Sweeping_Q_heuristic = Dyna_3D(
rand=rand,
maze=maze,
epsilon=epsilon,
gamma=gamma,
planningSteps=planningSteps,
qLearning=True,
expected=False,
alpha=alpha,
priority=True,
theta=theta,
heuristic=True)
models = [
model_Dyna_Prioritized_Sweeping_Q_heuristic, model_Dyna_Q,
model_Dyna_Prioritized_Sweeping_Q_A_star,
model_Dyna_Prioritized_Sweeping_Q, model_Dyna_Prioritized_Sweeping_ES
]
models = [
model_Dyna_Prioritized_Sweeping_Q_A_star,
model_Dyna_Prioritized_Sweeping_Q, model_Dyna_Prioritized_Sweeping_ES
]
for m, model in enumerate(models):
for run in range(0, runs):
print('run:', run, model.name, 'maze size:',
maze.WORLD_HEIGHT * maze.WORLD_WIDTH)
start_time = timer()
# track steps / backups for each episode
steps = []
# play for an episode
while True:
steps.append(model.play())
# print best action w.r.t. current state-action values
# printActions(currentStateActionValues, maze)
# check whether the (relaxed) optimal path is found
came_from = model.checkPath(len(go_to_all.keys()))
if came_from:
draw_grid_3d(diagram,
came_from=came_from,
start=tuple(maze.START_STATE),
goal=tuple(maze.GOAL_STATES),
title=model.name)
print(steps)
break
backups[run][m] = np.sum(steps)
print('Finish, using %.2f sec!' % (timer() - start_time))
# Dyna-Q performs several backups per step
backups = np.sum(backups, axis=0)
# average over independent runs
backups /= float(runs)
print(backups)
plt.show()
