def resetParamServer(): global params, accruedGradients, history_S, history_Y, rho,batches_processed nn = NeuralNetwork(NNlayers) params = nn.get_weights() accruedGradients = np.zeros(sum(nn.sizes)) history_S = [] history_Y = [] rho = [] batches_processed = 0
#data = np.array([[0,0,0],[0,1,1],[1,0,1],[1,1,0]],dtype=np.float64)
rawData = np.loadtxt("iris.data",delimiter=",") # Labels must be floats
np.random.shuffle(rawData)
label_count = len(set(rawData[:,-1]))
feature_count = len(rawData[0])-1
X, y = sliceData(rawData)
dataSetSize = len(X)
#######neural network #######################
NNlayers = [feature_count, 10, label_count] #
nn = NeuralNetwork(NNlayers) #
costFunction = nn.cost #
#############################################
params = nn.get_weights() #weights
accruedGradients = np.zeros(sum(nn.sizes))
old_gradients = None
old_params = None
maxHistory = 10
history_S = [] #s_k = x_kp1 - x_k
history_Y = [] #y_k = gf_kp1 - gf_k
rho = [] #rho_k = 1.0 / (s_k * y_k)
batches_processed = 0
batch_size = 10
def processedBatches():
return batches_processed
def main():
sc = sequenceClassifier()
ag = Agent()
cc = Ccea()
nn = NeuralNetwork()
if p["create_new_sets"] == 1:
sc.create_training_set()
sc.save_training_set()
sc.create_test_set()
sc.save_test_set()
else:
sc.load_training_set()
sc.load_test_set()
for s in range(p["s_runs"]):
print("Stat Run: ", s)
# Training
training_reward_history = []
test_reward_history = []
state_vec = np.ones(p["n_inputs"])
cc.create_new_population()
for gen in range(p["generations"]):
print("Gen: ", gen)
pop_id = cc.n_elites
while pop_id < p["pop_size"]: # Test each set of weights in EA
nn.reset_nn()
nn.get_weights(cc.population["pop{0}".format(pop_id)])
fitness_score = 0.0
for seq in range(p["train_set_size"]):
ag.reset_mem_block()
nn.clear_outputs()
seq_len = len(sc.training_set["set{0}".format(seq)])
current_sequence = sc.training_set["set{0}".format(
seq)].copy()
for num in range(seq_len):
state_vec[0] = current_sequence[num]
nn.run_neural_network(state_vec, ag.mem_block)
ag.update_memory(nn.wgate_outputs, nn.encoded_memory)
if nn.out_layer[0] < 0.5 and sc.training_set_answers[
seq, 2] == -1:
fitness_score += 1
elif nn.out_layer[0] >= 0.5 and sc.training_set_answers[
seq, 2] == 1:
fitness_score += 1
cc.fitness[pop_id] = fitness_score / p["train_set_size"]
pop_id += 1
# Testing
nn.reset_nn()
state_vec = np.ones(p["n_inputs"])
best_pol_id = np.argmax(
cc.fitness) # Find the best policy in the population currently
nn.get_weights(cc.population["pop{0}".format(best_pol_id)])
test_reward = 0.0
for seq in range(p["test_set_size"]):
ag.reset_mem_block()
nn.clear_outputs()
seq_len = len(sc.test_set["set{0}".format(seq)])
current_sequence = sc.test_set["set{0}".format(seq)].copy()
for num in range(seq_len):
state_vec[0] = current_sequence[num]
nn.run_neural_network(state_vec, ag.mem_block)
ag.update_memory(nn.block_output, nn.wgate_outputs)
if nn.out_layer[0] < 0.5 and sc.training_set_answers[seq,
2] == -1:
test_reward += 1
elif nn.out_layer[0] >= 0.5 and sc.training_set_answers[
seq, 2] == 1:
test_reward += 1
test_reward_history.append(test_reward / p["test_set_size"])
training_reward_history.append(max(cc.fitness))
cc.down_select()
save_reward_history(training_reward_history, "Training_Fitness.csv")
save_reward_history(test_reward_history, "Test_Reward.csv")
