def mnist_dataset():
digits = datasets.load_digits()
X = preprocessing.scale(digits.data.astype(float))
y = to_vector(digits.target, 10)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4)
nn = NeuralNetwork([64, 60, 10])
nn.back_propagation(X_train, y_train, epochs=15, learning_rate=0.1)
y_predicted = nn.predict(X_test)
y_predicted = np.argmax(y_predicted, axis=1).astype(int)
y_test = np.argmax(y_test, axis=1).astype(int)
print(metrics.classification_report(y_test, y_predicted))
def custom_dataset():
x, y = prepare_data("./Letters", 400, 7800, 26)
nn = NeuralNetwork([400, int(400 * 0.8), 26])
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.4)
nn.back_propagation(X_train, y_train, epochs=10, learning_rate=0.1)
y_predicted = nn.predict(X_test)
y_predicted = np.argmax(y_predicted, axis=1).astype(int)
y_test = np.argmax(y_test, axis=1).astype(int)
print(
metrics.classification_report(y_test,
y_predicted,
target_names=TARGET_NAMES))
def learn_function(training_data_x,
training_data_y,
test_data_x,
test_data_y,
nn: NeuralNetwork = None):
training_data_x = training_data_x.reshape((-1, 1))
training_data_y = training_data_y.reshape((-1, 1))
test_data_x = test_data_x.reshape((-1, 1))
test_data_y = test_data_y.reshape((-1, 1))
# build neural network
if nn is None:
nn = NeuralNetwork([
NeuralNetworkHiddenLayerInfo('relu', 1),
NeuralNetworkHiddenLayerInfo('tanh', 50),
NeuralNetworkHiddenLayerInfo('sigmoid', 20)
], 1)
# preprocess data for nn
scaler_x = MinMaxScaler((0, 1))
scaler_y = MinMaxScaler((0, 1))
scaled_x_train = scaler_x.fit_transform(training_data_x)
scaled_y_train = scaler_y.fit_transform(training_data_y)
scaled_x_test = scaler_x.fit_transform(test_data_x)
# learning
draw = 10000
for i in range(100000):
nn.feed_forward(scaled_x_train)
nn.back_propagation(scaled_y_train)
# drawing for test data
if i % draw == 0:
pr = nn.predict(scaled_x_test)
plt.scatter(test_data_x, test_data_y, 14)
plt.scatter(test_data_x, scaler_y.inverse_transform(pr), 14)
plt.title(
f'Iteration: {i} '
f'Error: {np.square(test_data_y - scaler_y.inverse_transform(nn.output)).mean()}'
)
plt.show()
plt.scatter(test_data_x, test_data_y)
plt.title(f'Function')
plt.show()
pr = nn.predict(scaled_x_test)
plt.scatter(test_data_x, scaler_y.inverse_transform(pr))
plt.title(
f'End, Error: '
f'{np.square(test_data_y - scaler_y.inverse_transform(pr)).mean()}')
plt.show()
else:
negatives.append(inputs[i])
positives_array = np.zeros((2, len(positives)))
negatives_array = np.zeros((2, len(negatives)))
for i in range(len(positives)):
positives_array[0, i] = positives[i][0, 0]
positives_array[1, i] = positives[i][1, 0]
for i in range(len(negatives)):
negatives_array[0, i] = negatives[i][0, 0]
negatives_array[1, i] = negatives[i][1, 0]
# Creating and training the neural network
neural_network = NeuralNetwork(2, 10, 1, 0.03)
costs = np.zeros(num_epochs)
for i in range(num_epochs):
neural_network.back_propagation(inputs, expected_outputs)
costs[i] = neural_network.compute_cost(inputs, expected_outputs)
print('epoch: %d; cost: %f' % (i + 1, costs[i]))
# Plotting cost function convergence
plt.plot(costs)
plt.xlabel('Epoch')
plt.ylabel('Cost')
plt.title('Cost Function Convergence')
plt.grid()
plt.savefig('cost_function_convergence.' + fig_format, format=fig_format)
# Plotting positive and negative samples
plt.figure()
plt.plot(positives_array[0, :], positives_array[1, :], '+r')
plt.plot(negatives_array[0, :], negatives_array[1, :], 'x')
def main():
# Initialise screen
pygame.init()
screen = pygame.display.set_mode((screen_x, screen_y))
pygame.display.set_caption(
'Pong Game Controlled by Artificial Neural Network')
# Fill background
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((255, 255, 255))
# Initialise players
global player1
global player2
player1 = Player("left")
player2 = Player("right")
# Initialise ball
speed = 13
rand = ((0.1 * (random.randint(5, 8))))
ball = Ball((0.47, speed))
# Initialise sprites
playersprites = pygame.sprite.RenderPlain((player1, player2))
ballsprite = pygame.sprite.RenderPlain(ball)
# Blit everything to the screen
screen.blit(background, (0, 0))
pygame.display.flip()
# Initialise clock
clock = pygame.time.Clock()
# Initialise NeuralNetwork
nn = NeuralNetwork()
nn.set_random_w()
input = [0, 0, 0]
output = [0]
t_output = [0]
# Font Initialization
pygame.font.init()
font_title = pygame.font.SysFont('Comic Sans MS', 20)
font_comment = pygame.font.SysFont('Comic Sans MS', 12)
text_title = font_title.render("Neural Network Pong", False, (0, 0, 0))
text_controls = font_comment.render(
"Keyboard control: 'a' - Player Up, 'y' - Player Down", False,
(100, 100, 100))
# Event loop
while True:
clock.tick(60)
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN:
if event.key == K_a:
player1.moveup()
if event.key == K_z:
player1.movedown()
if event.key == K_UP:
player2.moveup()
if event.key == K_DOWN:
player2.movedown()
elif event.type == KEYUP:
if event.key == K_a or event.key == K_z:
player1.movepos = [0, 0]
player1.state = "still"
if event.key == K_UP or event.key == K_DOWN:
player2.movepos = [0, 0]
player2.state = "still"
(x, y) = ball.get_position()
angle = ball.get_angle()
(xp, yp) = player2.get_position()
input[0] = x
input[1] = y
input[2] = angle
nn.set_input(input)
nn.feed_forward()
output = nn.get_output()
t_output[0] = y
nn.set_delta_output(t_output)
nn.back_propagation()
nn.adjust_w()
if output[0] > y:
player2.moveup()
else:
player2.movedown()
print('Output = {} Position = {}'.format(output[0], x))
screen.blit(text_title, (230, 0))
screen.blit(text_controls, (20, 450))
screen.blit(background, ball.rect, ball.rect)
screen.blit(background, player1.rect, player1.rect)
screen.blit(background, player2.rect, player2.rect)
ballsprite.update()
playersprites.update()
ballsprite.draw(screen)
playersprites.draw(screen)
pygame.display.flip()
class NetworkTest(TestCase):
def setUp(self) -> None:
"""
Sets up unittest
"""
self.network = NeuralNetwork(2, [5, 4], 1, [tanh, tanh, sigmoid], 0.1)
self.x_input = np.array([40, 40])
self.output = np.array([1.0])
self.batch_input = np.random.uniform(-50, 50, (2, SIZE))
self.batch_output = np.random.choice([0.0, 1.0], (1, SIZE))
def test_constructor_exception(self):
test = False
try:
NeuralNetwork(2, [1, 1], 1, [sigmoid], 0.1)
except IndexError:
test = True
assert test
net = None
try:
net = NeuralNetwork(2, [1, 1], 1, [sigmoid, tanh, tanh, sigmoid],
0.1)
except IndexError:
test = False
assert test
actual = net.feed_forward(self.x_input)
assert actual.shape == (1, 1)
def test_layers(self):
assert len(self.network.layers) == 3
a_network = NeuralNetwork(2, [], 1, [sigmoid], 0)
assert len(a_network.layers) == 1
assert a_network.layers[0].w.shape == (1, 2)
assert a_network.layers[0].activation_function == sigmoid
def test_feed_forward(self):
# As network:
actual = self.network.feed_forward(self.x_input)
# As layers
expected = self.network.layers[0].feed(self.x_input.reshape(-1, 1),
save=False)
assert np.equal(expected, self.network.layers[0].output).all()
expected = self.network.layers[1].feed(expected, save=False)
assert np.equal(expected, self.network.layers[1].output).all()
expected = self.network.layers[2].feed(expected, save=False)
assert np.equal(expected, self.network.layers[2].output).all()
assert np.equal(expected, actual).all()
def test_back_propagation(self):
# As layers
hidden_output1 = self.network.layers[-3].feed(self.x_input.reshape(
-1, 1),
save=False)
hidden_output2 = self.network.layers[-2].feed(hidden_output1,
save=False)
actual_output = self.network.layers[-1].feed(hidden_output2,
save=False)
error = actual_output - self.output
expected1 = np.multiply(error,
derivative[sigmoid](output=actual_output))
error = np.dot(self.network.layers[-1].w.T, expected1)
expected2 = np.multiply(error, derivative[tanh](output=hidden_output2))
error = np.dot(self.network.layers[-2].w.T, expected2)
expected3 = np.multiply(error, derivative[tanh](output=hidden_output1))
# As network
self.network.feed_forward(self.x_input)
self.network.back_propagation(self.output)
assert np.equal(expected1, self.network.layers[-1].delta).all()
assert np.equal(expected2, self.network.layers[-2].delta).all()
assert np.equal(expected3, self.network.layers[-3].delta).all()
def test_update_weight(self):
self.network.feed_forward(self.x_input)
self.network.back_propagation(self.output)
# Old weights
w1 = self.network.layers[0].w
b1 = self.network.layers[0].b
w2 = self.network.layers[1].w
b2 = self.network.layers[1].b
w3 = self.network.layers[2].w
b3 = self.network.layers[2].b
self.network.layers[0].update_weights(self.x_input.reshape(-1, 1), 0.1)
self.network.layers[1].update_weights(self.network.layers[0].output,
0.1)
self.network.layers[2].update_weights(self.network.layers[1].output,
0.1)
expected_list = [
self.network.layers[0].w, self.network.layers[0].b,
self.network.layers[1].w, self.network.layers[1].b,
self.network.layers[2].w, self.network.layers[2].b
]
# Return to old weights
self.network.layers[0].w = w1
self.network.layers[0].b = b1
self.network.layers[1].w = w2
self.network.layers[1].b = b2
self.network.layers[2].w = w3
self.network.layers[2].b = b3
self.network.update_weight(self.x_input)
actual = [
self.network.layers[0].w, self.network.layers[0].b,
self.network.layers[1].w, self.network.layers[1].b,
self.network.layers[2].w, self.network.layers[2].b
]
for index, expected in enumerate(expected_list):
assert np.equal(actual[index], expected).all()
def test_feed_forward_batch(self):
# As network:
actual = self.network.feed_forward(self.batch_input)
# As layers
expected = self.network.layers[0].feed(self.batch_input, save=False)
assert np.equal(expected, self.network.layers[0].output).all()
expected = self.network.layers[1].feed(expected, save=False)
assert np.equal(expected, self.network.layers[1].output).all()
expected = self.network.layers[2].feed(expected, save=False)
assert np.equal(expected, self.network.layers[2].output).all()
assert np.equal(expected, actual).all()
def test_back_propagation_batch(self):
# As layers
hidden_output1 = self.network.layers[-3].feed(self.batch_input,
save=False)
hidden_output2 = self.network.layers[-2].feed(hidden_output1,
save=False)
actual_output = self.network.layers[-1].feed(hidden_output2,
save=False)
error = actual_output - self.batch_output
expected1 = np.multiply(error,
derivative[sigmoid](output=actual_output))
error = np.dot(self.network.layers[-1].w.T, expected1)
expected2 = np.multiply(error, derivative[tanh](output=hidden_output2))
error = np.dot(self.network.layers[-2].w.T, expected2)
expected3 = np.multiply(error, derivative[tanh](output=hidden_output1))
# As network
self.network.feed_forward(self.batch_input)
self.network.back_propagation(self.batch_output)
assert np.equal(expected1, self.network.layers[-1].delta).all()
assert np.equal(expected2, self.network.layers[-2].delta).all()
assert np.equal(expected3, self.network.layers[-3].delta).all()
def test_update_weight_batch(self):
self.network.feed_forward(self.batch_input)
self.network.back_propagation(self.batch_output)
# Old weights
w1 = self.network.layers[0].w
b1 = self.network.layers[0].b
w2 = self.network.layers[1].w
b2 = self.network.layers[1].b
w3 = self.network.layers[2].w
b3 = self.network.layers[2].b
self.network.layers[0].update_weights(self.batch_input, 0.1)
self.network.layers[1].update_weights(self.network.layers[0].output,
0.1)
self.network.layers[2].update_weights(self.network.layers[1].output,
0.1)
expected_list = [
self.network.layers[0].w, self.network.layers[0].b,
self.network.layers[1].w, self.network.layers[1].b,
self.network.layers[2].w, self.network.layers[2].b
]
# Return to old weights
self.network.layers[0].w = w1
self.network.layers[0].b = b1
self.network.layers[1].w = w2
self.network.layers[1].b = b2
self.network.layers[2].w = w3
self.network.layers[2].b = b3
self.network.update_weight(self.batch_input)
actual = [
self.network.layers[0].w, self.network.layers[0].b,
self.network.layers[1].w, self.network.layers[1].b,
self.network.layers[2].w, self.network.layers[2].b
]
for index, expected in enumerate(expected_list):
assert np.equal(actual[index], expected).all()
def test_exception_train(self):
test = False
try:
self.network.train(self.batch_input, self.output)
except ValueError as e:
logging.info(e.__str__())
test = True
assert test
test = False
try:
self.network.update_weight(self.batch_input)
except ValueError as e:
logging.info(e.__str__())
test = True
assert test
def test_train_repeat(self):
learning, costs = self.network.train(self.batch_input,
self.batch_output,
epochs=EPOCHS,
repeat=True)
assert len(learning) == len(costs)
assert len(learning) == EPOCHS
def test_train_split(self):
learning, costs = self.network.train(self.batch_input,
self.batch_output,
epochs=EPOCHS)
assert len(learning) == len(costs)
assert len(learning) == EPOCHS
learning, costs = self.network.train(self.batch_input,
self.batch_output,
epochs=70)
assert len(learning) == len(costs)
assert len(learning) == 70
err_total = 0.0
for i in range(len(test_inputs)):
o = neuralnet.forward_propagate(test_inputs[data_no])
err = (test_outputs[data_no] - o)**2 / 2
err_total += err
return err_total
if __name__ == "__main__":
learning_time_limit = 10000 # 学習回数の上限(打ち切り条件)
error_boundary = 0.01 # 誤差値によるの終了判定基準
neuralnet = NeuralNetwork([2, 3, 1], 0.1, 1.0)
data_indexs = np.arange(len(teach_inputs))
for n in range(learning_time_limit):
np.random.shuffle(data_indexs)
for data_no in data_indexs:
# 順伝播計算
neuralnet.forward_propagate(teach_inputs[data_no])
# 逆伝播学習
neuralnet.back_propagation(teach_outputs[data_no])
# 検証
err = validate(neuralnet, teach_inputs, teach_outputs)
if err <= error_boundary:
print("finished in %d times of learning" % (n))
break
for data_no in range(len(teach_inputs)):
o = neuralnet.forward_propagate(teach_inputs[data_no])
print(o, (teach_outputs[data_no] - o)**2 / 2)
print("total")
print(validate(neuralnet, teach_inputs, teach_outputs))
