def __train_and_save(individuals, training_results_path,
training_program_path):
"""
Trains the individuals with the given traning program and save the logss
:param individuals: Individuals to train
:param training_results_path: Path to save logs to
:param training_program_path: Path to training program
:returns: Timestamp of the last completed workout
"""
column_names = ["ID", "Exercise", "Weight", "Reps", "Timestamp"]
training_logs = pd.DataFrame(columns=column_names)
# load training program
# perform training
for individual in individuals:
training_dataframe = gym.load_training(training_program_path,
individual.bench_press_movement)
performed_training = gym.train(training_dataframe, individual)
performed_training.insert(0, "ID", [individual.id] *
performed_training.shape[0], True)
training_logs = training_logs.append(performed_training)
# write training logs to given file path
training_logs.to_csv(training_results_path, sep="|", index=False)
return training_logs["Timestamp"].iloc[-1]
def perform_training(index, _from, _to):
# perform training
for individual in individuals[_from:_to]:
training_dataframe = gym.load_training(
training_program_path, individual.bench_press_movement)
performed_training = gym.train(training_dataframe, individual)
performed_training.insert(0, "ID", [individual.id] *
performed_training.shape[0], True)
training_logs_list[index] = training_logs_list[index].append(
performed_training)
epsilon_min=epsilon_min,
batch_size=batch_size)
def build_model(self):
model = Sequential()
model.add(Dense(12, input_shape=(self.state_size, ),
activation='relu'))
model.add(Dense(12, input_shape=(self.state_size, ),
activation='relu'))
model.add(Dense(2, activation='linear'))
model.compile(Adam(lr=self.learning_rate), 'mse')
model.load_weights("models/cartpole-v2.h5")
return model
if __name__ == '__main__':
rospy.init_node('cartpole3D_ruippeixotog',
anonymous=True,
log_level=rospy.FATAL)
episodes_training = rospy.get_param('/cartpole_v0/episodes')
episodes_running = rospy.get_param('/cartpole_v0/episodes_running')
max_timesteps = rospy.get_param('/cartpole_v0/max_timesteps', 10000)
gym = GymRunner('CartPoleStayUp-v0', '/tmp/cartpole-experiment-2',
max_timesteps)
agent = CartPoleAgent()
gym.train(agent, episodes_training)
agent.model.save_weights("/tmp/cartpole-v2.h5", overwrite=True)
gym.run(agent, episodes_running, do_train=False)
def infer_model_parameters(individuals_path, training_protocol_path,
performance_gain_mean, performance_gain_std,
threshold):
"""Run training study in accordance to given population parameters, training protocols and
expected results. The internal modelling parameters of the population will then be inferred
by trying random values until a good fit on performance is found for training population.
:param individuals_path: Path to the saved individuals to use.
:param training_protocol_path: Path to the training protocol to follow.
:param performance_gain_mean: The mean of peformance increases in terms of 1RM.
:param performance_gain_std: The standard deviation of performance increases in terms of 1RM.
:param threshold: The allowed difference between expected and actual mean and standard
deviation in performance gains.
:returns: The inferred internal model parameters and the resulting accuracy in terms of
difference between actual and expected performance.
"""
# load individuals
pre_training_individuals = load_individuals(individuals_path)
# construct training instructions to use for simulation for each individual
individual_training = create_training_dict(pre_training_individuals,
training_protocol_path)
# parameters to estimate
fitness_gain = 0
fatigue_gain = 0
fitness_decay = 0
fatigue_decay = 0
delta = 99999999999
best_delta = delta
iteration_mean = 0
iteration_stdev = 0
# Train individuals with randomized parameters and see if results are correct
while delta > threshold:
post_training_individuals = [
copy.deepcopy(individual)
for individual in pre_training_individuals
]
# Generate random parameters
fitness_decay = np.random.randint(2, 50)
# Integer between 1 and fitness_decay (fitness lasts longer than fatigue)
fatigue_decay = np.random.randint(1, fitness_decay)
# Float between 1 and 5
fitness_gain, fatigue_gain = np.random.uniform(1, 5, 2)
# Set same parameters to each individual and train them
for individual in post_training_individuals:
individual.bench_press_movement.fitness_decay = fitness_decay
individual.bench_press_movement.fatigue_decay = fatigue_decay
individual.bench_press_movement.fitness_gain = fitness_gain
individual.bench_press_movement.fatigue_gain = fatigue_gain
gym.train(individual_training[individual.id], individual)
iteration_mean, iteration_stdev = \
calculate_performance_gain_distribution(pre_training_individuals,
post_training_individuals)
delta = abs(performance_gain_mean - iteration_mean) + \
abs(performance_gain_std - iteration_stdev)
best_delta = min(delta, best_delta)
# update user on progress
print("Current iteration delta: {}".format(delta))
print("Best delta so far: {}".format(best_delta))
print("Distribution mean error: {}".format(
abs(iteration_mean - performance_gain_mean)))
print("Distribution standard deviation error: {}".format(
abs(iteration_stdev - performance_gain_std)))
print("fitness_gain: {}".format(fitness_gain))
print("fatigue_gain: {}".format(fatigue_gain))
print("fitness_decay: {}".format(fitness_decay))
print("fatigue_decay: {}".format(fatigue_decay))
# parameters have been found
return fitness_gain, fatigue_gain, fitness_decay, fatigue_decay, iteration_mean, iteration_stdev