class NNAgent(Agent):
def __init__(self, buy_in, n_players, ID=0):
self.n_opponents = n_players - 1
self.states = [buy_in, 0, None] # [current funds, bet amount, action]
self.earnings = 0
self.id = ID
self.evaluator = Evaluator()
self.n_opponents = n_players - 1
self.earnings = 0
self.id = ID
self.evaluator = Evaluator()
self.num_opp_actions = 5
self.num_feature_elements = 52 + (self.num_opp_actions * self.n_opponents) + 3
self.batch_size = 50000 # could have this as a parameter
# initialize neural network
self.network = NeuralNetwork(test_mnist=False, input_layer_size=self.num_feature_elements)
# array of feature vectors
self.X_train = np.empty([self.batch_size, self.num_feature_elements])
# array of target values (i.e. Q(feature vector))
self.y_train = np.empty([self.batch_size, 1])
self.prev_state_action_vector = None
self.e = 0.3 # value for e-greedy
self.iteration_num = 0
# get output of neural network
def Q(self, vector):
return self.network.predict(vector)
def trainQ(self):
self.network.updateData(train_data=self.X_train, train_labels=self.y_train, input_layer_size=self.num_feature_elements)
self.network.train(num_epochs=10)
def getAction(self, game, call, raise_amt):
cur_funds = self.states[0]
cur_bet = self.states[1]
diff = call - cur_bet
raise_bet = diff + raise_amt
action = None
# can't call
if diff > cur_funds:
action = 'F'
# can't raise
if raise_bet > cur_funds:
action_set = ['F', 'C']
# can do anything
else:
action_set = ['F', 'C', 'R']
# 52 elements to represent the hand, number opponents elements * 3 elements to represent last actions, 3 elements to represent agents action
state_action_vector = np.zeros(52 + self.num_opp_actions * self.n_opponents + 3)
# indicating the hand
state_action_vector[getCardNum(self.hole_cards[0])] = 1
state_action_vector[getCardNum(self.hole_cards[1])] = 1
other_player_actions = tuple(game.last_player_actions)
# indicating the opp. actions
for i in xrange(self.n_opponents):
state_action_vector[52 + self.num_opp_actions * i + action_numbers[other_player_actions[i]]] = 1
num_state_features = 52 + (self.num_opp_actions * self.n_opponents)
if not action:
# net has not been trained yet
if self.iteration_num < self.batch_size:
max_action_value = 0
action = random.choice(action_set)
else:
r = random.uniform(0, 1)
max_action_value = -np.inf
max_legal_action_value = -np.inf # might not be able to do every action
# choose best possible action
for (i, a) in enumerate(actions):
state_action_vector[num_state_features + i] = 1
action_value = self.Q(state_action_vector)
if action_value > max_action_value:
max_action_value = action_value
if a in action_set:
if action_value > max_legal_action_value:
max_legal_action_value = action_value
action = a
state_action_vector[num_state_features + i] = 0
# e-greedy exploration
if r < self.e:
action = random.choice(action_set)
else:
max_action_value = 0
# print action
state_action_vector[num_state_features + action_numbers[action]] = 1
if self.prev_state_action_vector is not None:
self.X_train[self.iteration_num % self.batch_size] = self.prev_state_action_vector
self.y_train[self.iteration_num % self.batch_size] = np.array(max_action_value)
self.iteration_num += 1
if self.iteration_num % self.batch_size == 0:
self.trainQ()
self.prev_state_action_vector = state_action_vector
return action
# add reward to training set
def QReward(self, reward):
if self.prev_state_action_vector is not None:
self.X_train[self.iteration_num % self.batch_size] = self.prev_state_action_vector
self.y_train[self.iteration_num % self.batch_size] = np.array(reward)
self.iteration_num += 1
if self.iteration_num % self.batch_size == 0:
self.trainQ()
self.prev_state_action_vector = None
def main():
script = str(sys.argv[1])
epochs = 3000
# script = 'example'
if script == "example":
x = np.array([[0.05, 0.1]])
y = np.array([[0.01, 0.99]])
desired_y = np.array([[0.773, 0.778]]) # After one training step (epoch)
parameters = {
"num inputs" : 2,
"num outputs" : 2,
"num hidden layers" : 1,
"num neurons" : 2,
"activations": ['sigmoid'] * 2,
"learning rate": 0.5,
"loss function": 'squared error'
}
nn = NeuralNetwork(parameters)
# In this example, don't use randomly-initialized weights - use the ones from the example. So, to make things
# simple, just over-write the existing, randomly-initialized weights from the NeuralNetwork instantiation.
weights = np.array([[0.15, 0.20, 0.25, 0.30], [0.40, 0.45, 0.50, 0.55]])
biases = np.array([[0.35, 0.35], [0.60, 0.60]])
for l in range(0, len(nn.layers)):
nn.layers[l].weights = weights[l]
nn.layers[l].biases = biases[l]
nn.layers[0].neurons[0].weights = weights[0, 0:2]
nn.layers[0].neurons[1].weights = weights[0, 2::]
nn.layers[0].neurons[0].bias = biases[0, 0]
nn.layers[0].neurons[1].bias = biases[0, 1]
nn.layers[1].neurons[0].weights = weights[1, 0:2]
nn.layers[1].neurons[1].weights = weights[1, 2::]
nn.layers[1].neurons[0].bias = biases[1, 0]
nn.layers[1].neurons[1].bias = biases[1, 1]
nn.train(x, y, epochs=1)
new_output = nn.calculate(x)
# Print to screen
print('\n')
print('Class example: single epoch')
print('--------------------------------------------------------------------------------')
print('Initial output is: {}. After one training step, the next output should be {}, (with sigmoid activation).'.format(y, desired_y))
print('New output is... {}'.format(new_output))
elif script == "and":
x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])
parameters = {
"num inputs": 2,
"num outputs": 1,
"num hidden layers": 0,
"num neurons": 0,
"activations": ['sigmoid'],
"learning rate": 0.1,
"loss function": 'squared error'
}
nn = NeuralNetwork(parameters)
nn.train(x, y, epochs=epochs)
# Plotting
plt.plot(nn.loss_epoch)
plt.grid()
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('AND Neural Network, {} activation and \n {} loss'.format(parameters['activations'][0], parameters['loss function']))
plt.show()
# Printing to screen
print('\n')
print('AND Gate Perceptron:')
print('--------------------------------------------------------------------------------')
print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.')
for input, output in zip(x, y):
print("MULTI-LAYER PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input,
output,
nn.calculate(
input)))
elif script == "xor":
x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])
parameters_perceptron = {
"num inputs": 2,
"num outputs": 1,
"num hidden layers": 0,
"num neurons": 0,
"activations": ['sigmoid'],
"learning rate": 0.1,
"loss function": 'squared error'
}
parameters_multilayer_perceptron = {
"num inputs": 2,
"num outputs": 1,
"num hidden layers": 1,
"num neurons": 4,
"activations": ['sigmoid'] * 2,
"learning rate": 0.1,
"loss function": 'squared error'
}
nn_single = NeuralNetwork(parameters_perceptron)
nn_single.train(x, y, epochs=epochs)
nn_multi = NeuralNetwork(parameters_multilayer_perceptron)
nn_multi.train(x, y, epochs=epochs)
# Plotting
plt.plot(nn_single.loss_epoch, label='Single Perceptron')
plt.ylabel('Loss')
plt.plot(nn_multi.loss_epoch, label='Multi-layer Perceptron')
plt.grid()
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend(loc='upper right')
plt.title('XOR Neural Network {} activation and \n {} loss'.format(
parameters_multilayer_perceptron['activations'][0], parameters_multilayer_perceptron['loss function']))
plt.show()
# Printing results to screen
print('\n')
print('XOR Gate: Single-layer Perceptron:')
print('--------------------------------------------------------------------------------')
print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.')
for input, output in zip(x, y):
print("SINGLE PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input, output, nn_single.calculate(input)))
print('\n')
print('XOR Gate: Multi-layer Perceptron:')
print('--------------------------------------------------------------------------------')
print('For y = 1, output should be >= 0.5. For y = 0, output should be < 0.5.')
for input, output in zip(x, y):
print("MULTI-LAYER PERCEPTRON: Output for input x = {} should be y = {}. Computed value: {}".format(input, output,
nn_multi.calculate(
input)))
kb = []
testKB = []
for i in range(10000):
kb.append((generateDispensableCard(), [1]))
kb.append((generateIndispensableCard(), [0]))
for i in range(1000):
testKB.append((generateDispensableCard(), [1]))
testKB.append((generateIndispensableCard(), [0]))
untrainedErrorOnKB = nn.test(knowledgeBase=kb)
print("untrainedErrorOnKB : ", untrainedErrorOnKB)
untrainedErrorOnTest = nn.test(knowledgeBase=testKB)
print("untrainedErrorOnTest : ", untrainedErrorOnTest)
for i in range(1000):
test = False
if not i % 20:
test = True
trainedErrorOnKBi = nn.train(knowledgeBase=kb, doTests=test)
print("trainedErrorOnKB", i, " :", trainedErrorOnKBi)
else:
trainedErrorOnKBi = nn.train(knowledgeBase=kb, doTests=test)
trainedErrorOnKB1000 = nn.test(knowledgeBase=kb)
print("trainedErrorOnKB1000 : ", trainedErrorOnKB1000)
trainedErrorOnTest = nn.test(knowledgeBase=testKB)
print("trainedErrorOnTest : ", trainedErrorOnTest)
print()
if __name__ == '__main__':
for i in range(10):
seed = random.randint(-65536, 65535)
random.seed(seed)
nn = NeuralNetwork(neuronsPerLayer=[27, 50, 5, 1])
kb = []
testKB = []
for i in range(10000):
kb.append((generateDispensableCard(), [1]))
kb.append((generateIndispensableCard(), [0]))
for i in range(1000):
testKB.append((generateDispensableCard(), [1]))
testKB.append((generateIndispensableCard(), [0]))
untrainedErrorOnKB = nn.test(knowledgeBase=kb)
untrainedErrorOnTest = nn.test(knowledgeBase=testKB)
trainedErrorOnKB1 = nn.train(knowledgeBase=kb)
for _ in range(1000):
nn.train(knowledgeBase=kb, doTests=False)
trainedErrorOnKB1000 = nn.test(knowledgeBase=kb)
trainedErrorOnTest = nn.test(knowledgeBase=testKB)
print("untrainedErrorOnKB : ", untrainedErrorOnKB)
print("untrainedErrorOnTest : ", untrainedErrorOnTest)
print("trainedErrorOnKB1 : ", trainedErrorOnKB1)
print("trainedErrorOnKB1000 : ", trainedErrorOnKB1000)
print("trainedErrorOnTest : ", trainedErrorOnTest)
print("seed : ", seed)
print()
card.setValue(random.randint(1, 5))
return (Suit.toInt(fireWork.getSuit()), fireWork.getValue(),
Suit.toInt(card.getSuit()), card.getValue())
if __name__ == '__main__':
nn = NeuralNetwork(neuronsPerLayer=[4, 4, 1])
trainKB = []
testKB = []
for i in range(2000):
trainKB.append((generateGoodCombo(), [1]))
trainKB.append((generateBadCombo(), [0]))
testKB.append((generateGoodCombo(), [1]))
testKB.append((generateBadCombo(), [0]))
untrainedErrorOnKB = nn.test(knowledgeBase=trainKB)
untrainedErrorOnTest = nn.test(knowledgeBase=testKB)
trainedErrorOnKB1 = nn.train(knowledgeBase=trainKB)
for _ in range(10):
nn.train(knowledgeBase=trainKB, doTests=False)
print()
trainedErrorOnKB10 = nn.test(knowledgeBase=trainKB)
trainedErrorOnTest = nn.test(knowledgeBase=testKB)
print("untrainedErrorOnKB : ", untrainedErrorOnKB)
print("untrainedErrorOnTest : ", untrainedErrorOnTest)
print("trainedErrorOnKB1 : ", trainedErrorOnKB1)
print("trainedErrorOnKB10 : ", trainedErrorOnKB10)
print("trainedErrorOnTest : ", trainedErrorOnTest)
print()
cost = ((test_y['pred_survived'] - test_y['Survived'])**2).mean()
test_y = test_y[['pred_survived']]
test_y.columns = ['Survived']
return test_y, cost
if __name__ == '__main__':
x, y = prep_train_data()
test_x, test_y = prep_test_data()
h_layers = [10, 10]
inputs = x.values
outputs = y.values
nn = NeuralNetwork(n_inputs=4,
n_outputs=2,
h_layers=h_layers,
inputs=inputs,
expected_outputs=outputs)
nn.open_session()
nn.make_model(is_weights_rand=True)
nn.make_tensor_board()
s = time.time()
nn.train(epochs=999, learning_rate=0.01, isliveplot=False)
raw_outputs, _ = nn.test(test_inputs=test_x.values,
test_outputs=test_y.values)
test_y, cost = categorize_output(raw_outputs, test_y)
test_y.to_csv('./data/my_submission.csv')
print('cost: ', cost)
e = time.time() - s
print("Training took ", e, "seconds")
nn.close_session()
nn.plot()
[7.54, 1.88],
[6.77, 3.56],
[9.0, 2.56],
[8.0, 2.0],
[2.31, 11.0],
[7.0, 4.5]
], dtype=float)
answers = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=float)
nn = NeuralNetwork(2, 3, 1, 0.1)
# training neural network
for i in range(0, 100000):
random_index = np.random.randint(0, np.size(answers))
nn.train(inputs[random_index], answers[random_index])
print("Training Complete\n")
# Get insect dimension from end user
input_width = float(input("Enter insect width:\t\t"))
input_length = float(input("Enter insect length:\t"))
# Get a trained guess
output = nn.feed_forward([input_width, input_length])
print("\nOUTPUT\n------")
if output < 0.5:
print("Ladybird")
else:
print("Stick Insect")