def create_population(self, count):
population = []
for _ in range(0, count):
# Create randon network
network = NeuralNetwork(self.nn_params_choices)
network.create_random()
population.append(network)
return population
def __init__(self, x, y, id, coefs=0, intercepts=0):
super(Player, self).__init__()
self.surf = pygame.Surface((25, 25))
self.surf.fill((255, 255, 255))
self.isJump = False
self.jumpCount = 8
self.rect = self.surf.get_rect(
center=(
x,
y,
)
)
self.command = 5
self.speed = 3
self.x = x
self.y = y
self.score = 0
if coefs == 0 and intercepts == 0:
self.coefs, self.intercepts = NeuralNetwork.generate_weights_intercepts()
else:
self.coefs = coefs
self.intercepts = intercepts
self.intercept = 0
self.alive = True
self.winner = False
self.id = id
def demo():
# make it reproducible by using a random seed
np.random.seed(5135134)
test_test = load_xor()
# load the neural network, (input, [hidden], output)+
# the hidden layers has to be an array of at least 2 layers.
neural = nn.MLP_NeuralNetwork(2, ([4, 6]), 1)
neural.train(test_test)
print(neural.test(test_test))
t0 = time()
x = np.linspace(0, 1, 200)
y = np.linspace(0, 1, 200)
intensity = []
for i in x:
temp = []
for j in y:
temp.append(neural.give_input([i, j]))
intensity.append(temp)
#setup the 2D grid with Numpy
x, y = np.meshgrid(x, y)
# now just plug the data into pcolormesh, it's that easy!
plt.pcolormesh(x, y, intensity)
plt.colorbar() # need a colorbar to show the intensity scale
plt.show() # boom
def kFold(k,
input,
output,
numhidden,
learningRate,
alfa,
lamb,
maxiter=1000,
type="MSE"):
db = dbmongo.Database()
input, output = shuffle(input, output, random_state=0)
nn = nnBatch.NeuralNetwork(input,
output,
numhidden=numhidden,
learningRate=learningRate,
lamb=lamb,
alfa=alfa,
type=type)
# divido il dataset in k parti e segno il numero di pattern per ogni partizione
sizePart = nn.numExamples // k
errorTrain = np.empty(k)
errorValidation = np.empty(k)
for i in range(0, k):
##aggiungo una riga di zeri se no non posso concatenere con vstack
setPass = np.zeros(shape=(1, nn.dimInput))
setOutPass = np.zeros(shape=(1, nn.dimOutput))
for j in range(0, k):
if (i != j):
# aggiungo la partizione al training set
setPass = np.vstack(
(setPass, input[(j * sizePart):(sizePart * (j + 1))][:]))
setOutPass = np.vstack(
(setOutPass,
output[(j * sizePart):(sizePart * (j + 1))][:]))
else:
# passo la partizione alla rete neurale come validation set
nn.setValidation(
input[(i * sizePart):(sizePart * (i + 1))][:],
output[(i * sizePart):(sizePart * (i + 1))][:])
# rimuovo la linea di zeri iniziali quando passo il training set
nn.setInput(setPass[1:][:])
nn.setOutput(setOutPass[1:][:])
# reinizializzo i pesi
nn.setWeights()
nn.train(maxiter)
errorTrain[i] = nn.errorShow[-1]
errorValidation[i] = nn.errorValidShow[-1]
db.insert(np.mean(errorTrain), np.mean(errorValidation), int(numhidden),
float(learningRate), float(alfa), float(lamb))
def breed(self, mother, father):
"""Make two children as parts of their parents.
Args:
mother (dict): Network parameters
father (dict): Network parameters
"""
children = []
for _ in range(2):
child = {}
#Loop through the parameters and pick params for the kid
for param in self.nn_params_choices:
child[param] = random.choice([mother.network[param], father.network[param]])
#create a new network object
network = NeuralNetwork(self.nn_params_choices)
network.create_set(child)
children.append(child)
return children
'n_neurons': 12,
'activation': 'ReLu',
},
'C': {
'n_inputs': 12,
'n_neurons': 16,
'activation': 'ReLu',
},
'output': {
'n_inputs': 16,
'n_neurons': 3,
'activation': 'Softmax',
},
}
# instantiate my model
mynet = NeuralNetwork(architecture=arc, loss='categorical crossentropy', optimizer='sgd')
# instantiate keras similar keras model
kerasnet = Sequential()
kerasnet.add(Dense(16, input_dim = 2, activation = 'relu'))
kerasnet.add(Dense(12, activation = 'relu'))
kerasnet.add(Dense(16, activation = 'relu'))
kerasnet.add(Dense(1, activation = 'softmax'))
## compile model
kerasnet.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])
# train my model
mynet.train(X_train, y_train, iterations = 1000)
# train keras model
kerasnet.fit(X_train, y_train, epochs = 1000)
plt.scatter(param1, param2, c=y)
plt.show()
# load in architecutre from .json file
with open('data/architecture.json', 'r') as outfile:
arc = json.load(outfile)
# establish loss function and optimizer
loss = 'categorical crossentropy'
optimizer = 'SGD'
# split data for training and testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# create NN instance
net = NeuralNetwork(architecture=arc, loss=loss, optimizer=optimizer)
# train network weights and biases
net.train(X_train,
y_train,
iterations=10000,
learning_rate=1.0,
decay=0.0,
momentum=None)
# measure accuracy
acc = accuracy_score(y_test, net.predict(X_test))
print('Test accuracy: {:.2f}'.format(acc))
# see network architecture
net.visualize_network()
def run_game():
pygame.init()
fps_clock = pygame.time.Clock()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Jumpy Block")
display = DisplayInfo()
ADDOBSTACLE = pygame.USEREVENT + 1
pygame.time.set_timer(ADDOBSTACLE, INTERVAL)
obstacles = pygame.sprite.Group()
all_sprites = pygame.sprite.Group()
players = []
obstacles_array = []
for i in range(POPULATION):
player = Player(start_pos[0], start_pos[1], i)
players.append(player)
all_sprites.add(player)
if isHuman:
break
# can be an arbitrary number I just set it as the same as the population for simplicity's sake
for i in range(POPULATION):
new_obstacle = Obstacle()
obstacles_array.append(new_obstacle)
obstacles.add(new_obstacle)
all_sprites.add(new_obstacle)
game_over = False
generation = 1
obstacle_init = 0
players[-1].winner = True
high_score_index = -1
high_score = -100
# main loop
while not game_over:
screen.fill((0, 0, 0))
alive = 0
for event in pygame.event.get():
if event.type == KEYDOWN and event.key == K_ESCAPE:
game_over = True
elif event.type == pygame.QUIT:
game_over = True
elif event.type == ADDOBSTACLE:
obstacles_array[obstacle_init].start()
obstacle_init += 1
obstacle_init %= POPULATION
for i, player in enumerate(players):
obstacles_array[obstacle_init-1].pass_player(player)
if isHuman:
pressed_keys = pygame.key.get_pressed()
player.human_update(pressed_keys)
high_score = player.score
else:
input = NeuralNetwork.generate_input(player, obstacles_array, i)
player.command = NeuralNetwork.produce_output(input, player.coefs, player.intercepts)
# print(player.command)
if player.score > high_score:
high_score = player.score
high_score_index = i
winner = players[i]
winner.winner = True
player.computer_update(player.command)
if pygame.sprite.spritecollideany(player, obstacles):
if isHuman:
player.kill()
game_over = True
else:
player.alive = False
player.kill()
for player in players:
if player.alive:
alive += 1
display.update(screen, high_score, alive, generation)
obstacles.update()
for cur_object in all_sprites:
screen.blit(cur_object.surf, cur_object.rect)
pygame.display.flip()
# reset game when all players are dead
if alive == 0:
for cur_object in all_sprites:
cur_object.kill()
for obstacle in obstacles:
obstacle.kill()
screen.fill((0, 0, 0))
print("starting next generation")
pygame.time.delay(2000)
winner = players[high_score_index]
print(high_score_index)
generation += 1
winner.reset(start_pos[0], start_pos[1])
players = []
obstacles_array = []
high_score_index = -1
high_score = -100
obstacle_init = 0
for i in range(POPULATION - 1):
new_player = Player(start_pos[0], start_pos[1], i, GeneticAlgo.mutateCoefs(winner.coefs),
GeneticAlgo.mutateIntercepts(winner.intercepts))
players.append(new_player)
all_sprites.add(new_player)
for i in range(POPULATION):
new_obstacle = Obstacle()
obstacles_array.append(new_obstacle)
obstacles.add(new_obstacle)
all_sprites.add(new_obstacle)
players.append(winner)
all_sprites.add(winner)
fps_clock.tick(60)
from src import NeuralNetwork
from testdata import create_spiral_data
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import json
# load in architecutre from .json file
with open('data/architecture.json', 'r') as outfile:
arc = json.load(outfile)
# create class instance
net = NeuralNetwork(architecture=arc)
# visualize network as reminder
net.visualize_network()
# load in weights and biases from previously saved trained weights and biases
net.load('data/savetest.json')
# create test data
X, y = create_spiral_data(1000, 3)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# make predictions
pred = net.predict(X_test)
# measure accuracy of predictions
acc = accuracy_score(y_test, pred)
print(f'Accuracy of loaded model: {acc}')
import src.NeuralNetwork as NN
import numpy as np
if __name__ == "__main__":
X = np.array([[0,0,1],
[0,1,1],
[1,0,1],
[1,1,1]])
y = np.array([[0], [1], [1], [0]])
nn = NN.NeuralNetwork(X,y)
for i in range(1000):
nn.feedforward()
nn.backprop()
print(nn.output)