Neural Networks

I’ve recently been working with neural networks and currently have a neural network class and a simple program to evolve the network weights.

The class and a few methods are defined in NeuralFunctions.py. The function createRandomWeights is currently set up to create a 9 neuron network when test = True and a completely random network when test = False.

Neural Network

The weights are defined as:

Neuron Weights

# Neural Network Class Functions
# NeuralFunctions.py
# Written in Python.  See http://www.python.org/
# Placed in the public domain.
# Chad Bonner 1.31.2015
# Based on Back-Propagation Neural Networks by
# Neil Schemenauer <nas@arctrix.com>

print "NeuralNet v1.0"
import math
import random
import numpy as np

weightLimit = 5 #Somewhat arbitrary choice

#-------------Support Functions----------------
random.seed()

def createRandomWeights(n, weightLimit, test):
    # n = number of neurons
    # create matrix for weights
    if test == True:
        weights = np.array([[0.0 for i in range(n)] for j in range(n)])
        weights[2,0] = random.uniform(-weightLimit,weightLimit)
        weights[2,1] = random.uniform(-weightLimit,weightLimit)        
        weights[3,0] = random.uniform(-weightLimit,weightLimit)        
        weights[3,1] = random.uniform(-weightLimit,weightLimit)        
        weights[4,2] = random.uniform(-weightLimit,weightLimit)
        weights[4,3] = random.uniform(-weightLimit,weightLimit)        
    else:
        weights = np.array([[random.uniform(-weightLimit,weightLimit)
        for i in range(n)] 
            for j in range(n)])
    return weights

def createNets(numNets, sizeNet, numOut):
    # Create population of neural nets
    # Create a set of network connection weights with random weights
    # Instantiate nets and load with weights
    # Set test = True to use predefined weights
    test = True
    nets = [] #create empty variable to hold neural nets
    for id in range(numNets):
        #create weights for neuron connections
        weights = createRandomWeights(sizeNet, weightLimit, test)
        #instantiate a neural net
        # id=0, number of neurons, number of outputs, dna
        nets.append(NeuralNet(id, sizeNet, numOut, weights))
    return nets

# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
    # init output variable
    y = np.array([0.0]*len(x))        
    for i in range(len(x)):
        y[i] = math.tanh(x[i])*2    
    return y


#------------ Neural Net Class Definition ------------------------------
class NeuralNet:
    def __init__(self, id, n, no, weights):
        # n = number of neurons
        # no = number of outputs
        self.id = id
        self.n = n
        self.no = no
        self.weights = weights
        # activations for nodes
        self.ai = np.array([0]*self.n) #make all inputs neutral
        self.an = np.array([0]*self.n) #neuron outputs
        self.summ = np.array([0]*self.n) #init neuron activation levels to 0
    def identifyNet(self):
        print 'Net ', self.id
    def update(self, neuronInputs):
        # init neuron activation levels to 0
        self.summ = np.array([0]*self.n)
        # Apply inputs to input neurons
        self.ai[:len(neuronInputs)] = neuronInputs      
        # Add neuron inputs to activation level
        self.summ = self.ai + np.dot(self.weights, self.an)
        # set neuron outputs
        self.an = sigmoid(self.summ)
        # net output is the output from the last no neurons
        out = (self.an[self.n-self.no:])
        #print "out", out

        return out

# Evolution.py
# 
# Written in Python.  See http://www.python.org/
# Placed in the public domain.
# Chad Bonner 1.31.2015

from __future__ import division
import NeuralFunctions as nf
import weightedRandomChoice as wrc
import random
import numpy as np
import csv
import operator
from collections import defaultdict


# Setup
numGenerations = 50     #number of generations
numIterations = 4   #number of times to run each net
numNets =2000 #Size of the population
sizeNet = 5 #Number of neurons in each net
numOut = 1 #Number of outputs for each net
nets = [] #create empty variable to hold neural nets
nextGenNets = [] #create empty variable to hold neural nets
netFitness = {} #dictionary to hold net index and fitness
indexParents = [] #index of nets to be parents of next gen
parentDNA = [] #dna of parents
childDNA = [] #dna of children in the next gen

inputs = np.array([[0,0],[1,0],[0,1],[1,1]])
#============================================================================
#inputs = np.array([[0,0,0,0],[0,0,0,1],[0,0,1,0],[0,0,1,1],
#          [0,1,0,0],[0,1,0,1],[0,1,1,0],[0,1,1,1],
#          [1,0,0,0],[1,0,0,1],[1,0,1,0],[1,0,1,1],
#          [1,1,0,0],[1,1,0,1],[1,1,1,0],[1,1,1,1]])
#============================================================================

def netEvaluate(nets, inputs):
    #Apply input to each net and evaluate fitness
    fitness = {} #dictionary to hold net index and fitness    
    for index, net in enumerate(nets):
        #let signals progagate through net for iterations
        #then look at output
        fitness[index] = 0
        for i in range(len(inputs)):
            #print "Input:", i
            for c in range(numIterations): #allow for propgation to output
                out = net.update(inputs[i])
            out = net.update(inputs[i])    
#============================================================================        #Modify fitness here to suit application
    #Arbitrary choice of matching for input pattern 0101. A correct match
    #will have an output of 1 for an input of 0101 and an output of -1 for
    #all other input patterns. 
            #Set out = [1,0] for even input
#            if np.any(np.all(np.equal(inputs[i], 
#            [[0,0,0,0],[0,0,1,0],[0,1,0,0],[0,1,1,0],[1,0,0,0],
#             [1,0,1,0],[1,1,0,0],[1,1,1,0]]), 1)):
#                if out[0] >= 1 and out[1] < 0.2:
#                    fitness[index] = fitness[index] + 1 #award points
#            else:
#                if out[0] < 0.2 and out[1] >= 1:
#                    fitness[index] = fitness[index] + 1 #award
#============================================================================
#============================================================================
#         #Modify fitness here to suit application
            if np.any(np.all(np.equal(inputs[i], [[0,1],[1,0]]), 1)):
                #print "Should be 1: Out =", out
                if out >= [0.9]:
                    fitness[index] = fitness[index] + 1 #award points
                    #print "Rewarded for +1 output"
            else:
                #print "Should be 0: Out =", out
                if out < [0.2]:
                    fitness[index] = fitness[index] + 1 #award
                    #print "Rewarded for 0 output"
        if fitness[index] == 4:
            fitness[index] = 15 #award a lot of points for correct answer
#============================================================================
    return fitness

def writeFile(f, generation, fitness, fitIndex, nets, inputs, writeAll):
    # Write data to CSV file
    outputs = [] #create empty variable to hold net outputs
    writer = csv.writer(f, delimiter=',')
    if writeAll == True:    
        for net in nets:        
            writer.writerow(['Generation', 'Fitness', 'ID', 'SizeNet',
            'NumOut', 'Weights'])
            writer.writerow([generation, fitness, net.id, net.n, net.no])
            for j in range(net.n):
                writer.writerow(net.weights[j])
    else:
        writer.writerow(['Generation', 'Fitness', 'ID', 'SizeNet',
        'NumOut', 'Weights'])
        writer.writerow([generation, fitness, nets[fitIndex].id,
        nets[fitIndex].n,            
            nets[fitIndex].no])
        for i in range(len(inputs)):
            for c in range(numIterations):
                nets[fitIndex].update(inputs[i])
            outputs.append(nets[fitIndex].update(inputs[i]))
        writer.writerow(outputs)        
        print outputs
        for j in range(nets[fitIndex].n):
            writer.writerow(nets[fitIndex].weights[j])
    return
    
def breed(netFitness, nets):
    # Create new population by combining 
    # parents's dna (sexual reproduction).
    # Each net can combine with any other net, even itself.
    #print netFitness
    pairs = zip(netFitness.values(),netFitness.keys())
    pairs.sort()
    pairs.reverse()
    nextGenNets = [] # clear next gen variable for use
    for c, net in enumerate(nets):
        mom = wrc.weighted_random_choice(pairs)        
        #print "mom", mom
        dad = wrc.weighted_random_choice(pairs)        
        #print "dad", dad        
        childDNA = np.array([[0.0 for i in range(net.n)]
            for j in range(net.n)])
        for neuron in range(net.n):
            #take one neuron from each parent and combine to form child        
            childDNA[neuron,:] = nets[random.choice((mom,dad))].weights[neuron,:]
        # now create new net using child dna
        # instantiate a neural net
        nextGenNets.append(nf.NeuralNet(c, net.n, net.no, childDNA))
    return nextGenNets

# ------------------------- Main Routine ------------------------------
#def main():
#Open file to save data
csvfile = open('data_out.csv', 'wb')

#Create and evaluate initial population of neural nets
print "Genesis!"
nets = nf.createNets(numNets, sizeNet, numOut)
# Apply input to each net and evaluate fitness
netFitness = netEvaluate(nets, inputs)
fitHistogram = defaultdict(int) #variable to hold count of fitness values    
#Count frequency of fitness values
for value in netFitness.values(): fitHistogram[value] += 1
#print fitHistogram
print "Generation Fitness:", "%.3f"%((sum(netFitness.values())/numNets))
# Identify net with maximum fitness and save to log file
mostFit = max(netFitness.iteritems(), key=operator.itemgetter(1))[0]
mostFitness = netFitness[mostFit]
print "Most Fit:", mostFit
writeFile(csvfile, 0, mostFitness, mostFit, nets, inputs, False)

# Go forth and multiply
for generation in range(1, numGenerations):
    #Breed next generation
    nets = breed(netFitness, nets)
    print " "        
    print "Generation:", generation, "born"    
    # Apply input to each net and evaluate fitness
    netFitness = netEvaluate(nets, inputs)
    fitHistogram = defaultdict(int) #variable to hold count of fitness values    
    #Count frequency of fitness values
    for value in netFitness.values(): fitHistogram[value] += 1
    print fitHistogram
    print "Generation Fitness:", "%.3f"%((sum(netFitness.values())/numNets))
    # Identify net with maximum fitness and save to log file
    mostFit = max(netFitness.iteritems(), key=operator.itemgetter(1))[0]
    mostFitness = netFitness[mostFit]
    print "Most Fit:", mostFit
    writeFile(csvfile, generation, mostFitness, mostFit, nets, inputs, False)
    #print "Best net saved"
    #print "Iteration", generation, "complete!"
csvfile.close()
print "Done!"

Currently it takes about 12 seconds to run a population of 50 nets of 500 neurons each for 50 cycles. I’m using numpy to speed things up. I’m sure there are still opportunities for improvement. Creating the nets actually takes longer than running them as shown below (click to enlarge).

Neural Network Run Time