def __init__(self, a, b, countTeachElement,
countNeurons, sumError, functionText="math.sin(x)", debug=False):
self.debug = debug
self.countTeachElement = countTeachElement
self.countNeurons = countNeurons
self.maxError = sumError
for i in range(0, countNeurons):
self.state.layer1.append(neuron(1))
self.state.layer2.append(neuron(countNeurons))
self.__functionText = functionText
self.__inputCollection = self.__buildInputCollection(a, b, countTeachElement)
self.__teachCollection = self.__buildTeachCollection(self.__inputCollection)
self.__scaleCollection = self.__buildScaleCollection(self.__teachCollection)
def create_empty_red(self, order=[1, 3, 1]):
for i in range(len(order)):
if i == 0: # Capa de entrada
layer = []
for z in range(order[i]
): # se crea la cantidad de neuronas en la capa
layer.append(neuron(None, None, None, 0, z))
layer.append(neuron(None, None, None, None,
None)) #se le añade el bias neuron
self.red.append(layer)
logging.info("Se creo capa de entrada con %s neuronas",
order[i])
continue
if i < (len(order) - 1): # Capa Oculta
layer = []
for z in range(order[i]
): # se crea la cantidad de neuronas en la capa
layer.append(
neuron(
None,
np.random.uniform(low=0,
high=1,
size=(len(self.red[-1]))), None,
0, z))
layer.append(neuron(None, len(self.red[-1]), None, None,
None)) # se le añade el bias neuron
self.red.append(layer) # conecta la capa actual a NN
logging.info("Se creo capa de oculta con %s neuronas",
order[i])
continue
if i == len(order) - 1: # Capa de Salida
layer = []
for z in range(order[i]
): # se crea la cantidad de neuronas en la capa
layer.append(
neuron(
None,
np.random.uniform(low=0,
high=1,
size=(len(self.red[-1]))), None,
0, z))
self.red.append(layer) # conecta la capa actual a NN
logging.info("Se creo capa de Salida con %s neuronas",
order[i])
continue
self.connect_layers()
def create_list_of_neurons(size, start_label, layer_type, prev_layer_size,
activation_function, learning_rate):
l = []
for ii in range(0, size):
l.append(
neuron.neuron(start_label + ii, layer_type, prev_layer_size,
activation_function, learning_rate))
return l
def __init__(self, input_len, hidden_len, hidden_num, output_len):
self.input_len = input_len
self.hidden_num = hidden_num
self.hidden_len = hidden_len
self.output_len = output_len
self.input_layer = [-999 for i in range(0, input_len)]
self.hidden_layers = [[
neuron('Relu', input_len) for i in range(hidden_len)
]]
if hidden_num != 0:
for k in range(hidden_num - 1):
self.hidden_layers.append(
[neuron('Relu', hidden_len) for i in range(hidden_len)])
# Commented below is half-broken code for hidden layer initiliazation with varying hidden layer lengths
#self.hidden_layers.append([neuron('Relu',len(self.hidden_layers[j])) for k in range(0,hidden_len)])
self.output_layer = [
neuron('sigmoid', hidden_len) for i in range(0, output_len)
]
def __buildLayerNeurons(self):
layer = np.empty(self.numberOfBiasNeurons + self.numberOfNeurons,
dtype=object)
for i in range(self.numberOfBiasNeurons):
layer[i] = neuron(layerName=self.layerName,
layerNeuronNumber=i + 1,
isBiasNeuron=True)
pass
for i in range(self.numberOfNeurons):
if self.isInputLayer:
if isinstance(self.inputLayerInputs, type(None)):
layer[i + self.numberOfBiasNeurons] = neuron(
layerName=self.layerName,
layerNeuronNumber=i + self.numberOfBiasNeurons + 1,
isInputNeuron=self.isInputLayer)
pass
else:
layer[i + self.numberOfBiasNeurons] = neuron(
layerName=self.layerName,
layerNeuronNumber=i + self.numberOfBiasNeurons + 1,
isInputNeuron=self.isInputLayer,
input=self.inputLayerInputs[i])
pass
pass
elif self.isOutputLayer:
# Outputlayer has no bias Neurons
layer[i] = neuron(layerName=self.layerName,
layerNeuronNumber=i + 1,
isOutputNeuron=True)
pass
else:
layer[i + self.numberOfBiasNeurons] = neuron(
layerName=self.layerName,
layerNeuronNumber=i + self.numberOfBiasNeurons + 1)
pass
pass
return layer
pass
def __init__(self,
a,
b,
countTeachElement,
countNeurons,
sumError,
functionText="math.sin(x)",
debug=False):
self.debug = debug
self.countTeachElement = countTeachElement
self.countNeurons = countNeurons
self.maxError = sumError
for i in range(0, countNeurons):
self.state.layer1.append(neuron(1))
self.state.layer2.append(neuron(countNeurons))
self.__functionText = functionText
self.__inputCollection = self.__buildInputCollection(
a, b, countTeachElement)
self.__teachCollection = self.__buildTeachCollection(
self.__inputCollection)
self.__scaleCollection = self.__buildScaleCollection(
self.__teachCollection)
def atquestion(request, userid, questionid):
userid = int(userid)
questionid = int(questionid)
print(questionid)
if request.POST.has_key("choice") == 0:
return get_response(403, '{"message":"no choice"}', {})
p = Question.objects.filter(id=questionid)
if p.count() == 0:
return get_response(403, '{"message":"no question"}', {})
e = Users.objects.filter(id=userid)
if e.count() == 0:
return get_response(403, '{"message":"no use"}', {})
userid = Users.objects.filter(id=userid)[0]
questionid = Question.objects.filter(id=questionid)[0]
if request.POST["choice"] == p[0].answer:
l = "right"
else:
l = "wrong"
e = UserQuestion.objects.filter(questionid=questionid,
userid=userid,
righte=0)
if e.count() == 0:
z = UserQuestion(righte=1,
questionid=questionid,
userid=userid,
answer=request.POST["choice"],
time=datetime.now(),
right=p[0].answer,
correct=l)
z.save()
if p[0].answer == request.POST["choice"]:
e = neuron(userid, questionid)
return get_response(200, '{"message":"right"}', {})
else:
w = neuron(userid, questionid)
return get_response(200, '{"message":"wrong"}', {})
def __init__(self, DNA, xPos, yPos):
#this is a boolean representing if the agent is dead or alive, 1 means alive, 0 means dead
#if this is zero, the agents AI will stop running, effectively killing the agent
self.alive = bool
self.alive = 1
#this is the DNA of the agent, an array which describes all the properties of an agent which can change, effectively defining this agent
#and allowing it to be recreated elswhere in the program. The array contains, in order:
#the colour of the agent in RGB, the spread of the agent's eyes,
#the 2x3-array representing the default charge of each neuron, and the 3x3x3-array representing the mesh between the two layers of neurons
#and the outputs
self.DNA = self.limit(DNA)
#this holds the list of points which define the shape of the agent (a triangle)
self.pointList = [(xPos, yPos), (xPos - 15, yPos + 5),
(xPos - 15, yPos - 5)]
#these are important enough to exist outside pointlist, since they are used all over the place and referenceing an index in poitslist
#would be a pain for the processor
self.xPos = xPos
self.yPos = yPos
#these variables will be useful later
#the speed the agent is moving
self.vel = 0
#the angle the agent is at (relative to horizontal)
self.theta = 0
#this is the eyes of the organism/agent/whatever, ititialized at its min so the organism doesn't freak out
self.eyes = [0, 0, 0]
#this is the angle of spread between the middle eyes and the two outer ones
self.spread = DNA[1]
#here's where the fancy AI stuff starts
#so the brian of the agent is divided into two layers of neurons with inputs and outputs on wither side
#the inputs are the agent's eyes, which give info to the first layer of three neurons
#the first layer of neurons then multiplies the data by a certain constant and then passes it on to the second layer
#the second layer then does the same things and controls the three outputs, one to make the agent move forward and backward,
#and two to turn left and right
#this is the collection of neurons which make up the agent's brain
# 0 is colour 1 is spread, 2 is defaults, 3 is mesh
#self.brain = [[neuron(0,(0,0,1)),neuron(0,(0,0,0)),neuron(0,(1,0,0))],[neuron(0,(1,0,0)),neuron(1,(0,1,0)),neuron(0,(0,0,1))]]
self.brain = [[
neuron(DNA[2][0][0], DNA[3][1][0]),
neuron(DNA[2][0][1], DNA[3][1][1]),
neuron(DNA[2][0][2], DNA[3][1][2])
],
[
neuron(DNA[2][1][0], DNA[3][2][0]),
neuron(DNA[2][1][1], DNA[3][2][1]),
neuron(DNA[2][1][2], DNA[3][2][2])
]]
#this is the mesh which controls how data is passed from the inputs (eyes) to the first layer of neurons
#this is done because treating eyes like neurons would be an unneccessary amount of overhead
#self.meshOne = [[1,0,0],[0,1,0],[0,0,1]]
self.meshOne = DNA[3][0]
def __init__(self, num_rows, num_columns, data_set, name_of_data_set, num_nodes, end_of_num_layers_array, layerNumber, learning_rate): self.data_set = data_set self.num_rows = num_rows self.num_columns = num_columns self.list_of_neurons = [] for row in range(num_rows): inputs = [] for column in range(num_columns): if column != num_columns - 1: inputs.append(data_set[row][column]) for i in range(num_nodes): the_neuron = n.neuron(inputs, end_of_num_layers_array, layerNumber, learning_rate) self.list_of_neurons.append(the_neuron) self.name_of_data_set = name_of_data_set self.results_of_run = [] self.num_nodes = num_nodes self.str_results_of_run = []
def __init__(self,
neuralNetSkeleton,
inputVecRank,
InitialWeight=0,
activationType="THRES"):
""" Intializes a neuralnetwork of N layers
NeuralNet = [ (1,(neuron(), neuron(),..., neuron())),
(2,(neuron(), neuron(),..., neuron())),
...
(n,(neuron(), neuron(),..., neuron())),
Args:
neuralNetSkeleton: Tupule list of (layer, Number of Neurons)
e.g ((1, 7 ), (2, 3), (3, 2)) is a three layer with the first layer having 7 neurons,
the second layer of three neurons and the third layer of two neurons
inputVecRank: the dimension of the input samples
InitialWeight: the initial weights for the neural network
activationType: Three kinds of activation functions "THRES", "LINEAR", "SIGMOID"
"""
self.__neuralNetSkeleton = neuralNetSkeleton
self.__neuralNet = []
self.__inputVecRank = inputVecRank
for layerNumber, noNeuronsInThisLayer in self.__neuralNetSkeleton:
weightVectorForThisLayer = [InitialWeight
] + [InitialWeight] * inputVecRank
neuronListForThisLayer = tuple([
neuron(weightVector=weightVectorForThisLayer,
actFuncType=activationType)
for i in range(0, noNeuronsInThisLayer)
])
self.__neuralNet.append([layerNumber, neuronListForThisLayer])
# the input rank or dimension for the next layer is the output dimension of this layer
# assuming that we have a completely connected feedforward network
inputVecRank = noNeuronsInThisLayer
self.__neuralNet.sort()
def __init__(self, ins, outs):
# Undo related
self.last_neuron = None
self.last_bias = self.last_bias2 = None
self.last_weight = None
self.last_post = None
# Store a copy of the parameters
self.ins = ins; self.outs = outs
self.curr = 0 # Current Neuron in creation progress
# Create lattice
self.cont = []; cnt = 0
for aa in range(ins):
self.cont.append([])
for bb in range(outs):
self.cont[aa].append(neuron.neuron(self.ins, cnt, self.curr))
self.curr += 1
cnt += 1
def __init__(self, num_rows, num_columns, data_set, name_of_data_set,
num_nodes, end_of_num_layers_array, layerNumber,
learning_rate):
self.data_set = data_set
self.num_rows = num_rows
self.num_columns = num_columns
self.list_of_neurons = []
for row in range(num_rows):
inputs = []
for column in range(num_columns):
if column != num_columns - 1:
inputs.append(data_set[row][column])
for i in range(num_nodes):
the_neuron = n.neuron(inputs, end_of_num_layers_array,
layerNumber, learning_rate)
self.list_of_neurons.append(the_neuron)
self.name_of_data_set = name_of_data_set
self.results_of_run = []
self.num_nodes = num_nodes
self.str_results_of_run = []
import neuron as nr inputA = nr.neuron(0) inputB = nr.neuron(0) inputC = nr.neuron(0) norGate = nr.neuron([inputA, inputB, inputC], [-1, -1, -1], 0) print(norGate.getOutput())
import numpy as np
import math
from neuralsystem import neuralsystem
from neuron import neuron
if __name__ == '__main__':
print "hello"
actthreshold = 0.3
smell1 = neuron(0, 'inputneuron', actthreshold)
smell2 = neuron(1, 'inputneuron', actthreshold)
pro1 = neuron(2, 'proneuron', actthreshold)
pro2 = neuron(3, 'proneuron', actthreshold)
pro3 = neuron(4, 'proneuron', actthreshold)
out = neuron(5, 'outneuron', actthreshold)
templist = [pro1, pro2, pro3]
for neuron in templist:
smell1.add_outconnects([neuron, 0.4])
smell2.add_outconnects([neuron, 0.4])
neuron.add_inconnects([smell1, 0.4])
neuron.add_inconnects([smell2, 0.4])
neuron.add_outconnects([out, 0.2])
out.add_inconnects([neuron, 0.2])
for neuron2 in templist:
neuron.add_outconnects([neuron2, 0.3])
neuron.add_inconnects([neuron2, 0.3])
templist = [smell1, smell2, pro1, pro2, pro3, out]
network = neuralsystem('network1', templist)
network.birth(10)
data = []
for i in range(ndata):
foo = fin.readline().split()
for i in range(len(foo)):
try:
foo[i]=int(foo[i])
except:
pass
data.append([foo[:inputs],foo[inputs:inputs+outputs]])
layers = []
for l in range(hlayers+1):
arr = []
for i in range(nhnodes[l]):
if l == 0:
arr.append(neuron.neuron(inputs))
else:
arr.append(neuron.neuron(nhnodes[l-1]))
layers.append(arr)
if not interactive:
start = time.time()
sys.stdout.write('Learning...')
sys.stdout.flush()
for k in range(niter):
for i in range(ndata):
#Feed Forward
indata = data[i][0]
# print indata
for l in range(len(layers)):
nextdata = []
import numpy as np #import torch import random from neuron import neuron input = [0 for i in range(0, 9)] hidden = [neuron(input) for i in range(0, 5)] output = [neuron(hidden) for i in range(0, 2)] cost = np.dot()
from lines import *
from neuron import neuron
from rules import *
from spike_train import *
T = 100
dt = .1
dimen = 10
i_inc = .00725
v_decay = .002
neurons = [
[[[neuron() for x in range(dimen)] for y in range(dimen)]
for z in range(dimen)],
[neuron() for x in range(dimen)],
]
weights = [full((dimen, dimen, dimen), 1)]
times = arange(0, T + dt, dt)
for i, net in enumerate(neurons[0]):
for neuron in net[i]:
neuron.on = True
def integrate(i, layer, st):
for j, n in enumerate(neurons[layer]):
from neuron import neuron
from gsom import gsom
from gridPosition import gridPosition
import numpy as np
#Test Neuron class
vectorA=[0.1,0.2,0.3]
a = neuron(vectorA,0)
vectorB=[0.2,0.3,0.4]
b=neuron(vectorB,0)
vectorC=[0.3,0.4,0.5]
c= neuron(vectorC,0)
vectorD=[0.5 ,0.6 ,0.7]
d=neuron(vectorD,0)
#Initial neural network
#Initial SOM
som = {}
som[gridPosition(0,0)] = a
som[gridPosition(1,0)] = b
som[gridPosition(0,1)] = c
som[gridPosition(1,1)] = d
for i,value in som.iteritems():
print value.getweightVector()
# print len(i.getNeighbours())
#Test GSOM class
input = np.array(
T = 200 time = np.arange(1, T+1, 1) t_back = -20 t_fore = 20 Pth = 150 #Should be Pth = 6 for deterministic spike train m = 784 #Number of neurons in first layer n = 8 #Number of neurons in second layer epoch = 1 num_of_images = 6 w_max = 0.5 w_min = -0.5 layer2 = [] # creating the hidden layer of neurons for i in range(n): a = neuron() layer2.append(a) #synapse matrix synapse = np.zeros((n,m)) #learned weights weight_matrix = learned_weights() for i in range (num_of_images): synapse[i] = weight_matrix[i] #random initialization for rest of the synapses for i in range(num_of_images,n): for j in range(m): synapse[i][j] = random.uniform(w_min,w_max) for k in range(epoch):
def build_N_learn(lamda):
tset = os.listdir(directory)
for n in tset:
p = picture.Pic(os.path.join(directory, n))
filename = n.split(".")
imageVectors[filename[0]] = p.getVector()
TotalErr = 0.0
Err = 0
iteration = 0
while (Err == 0.0 or TotalErr > 2 and iteration < 2500):
if iteration % 20 == 0:
print "total error till " , iteration ,"th iteration is :", TotalErr
iteration = iteration+1
TotalErr = 0
for k in imageVectors.keys():
for i in range(firstLayer):
if len(inputNeurons) < firstLayer:
f = neuron.neuron(len(imageVectors[k]), lamda)
f.setWeights()
inputNeurons.append(f)
for y in range(len(imageVectors[k])):
inputNeurons[i].setInput(y+1, imageVectors[k][y])
inputNeurons[i].computeBaseFunction()
inputNeurons[i].computeOutput()
#print k
for i in range(hiddenLayer):
if len(hiddenNeurons) < hiddenLayer:
h = neuron.neuron(firstLayer, lamda)
h.setWeights()
hiddenNeurons.append(h)
for y in range(firstLayer):
hiddenNeurons[i].setInput(y+1, inputNeurons[y].getOutput())
hiddenNeurons[i].computeBaseFunction()
hiddenNeurons[i].computeOutput()
for i in range(lastLayer):
if len(lastNeurons) < lastLayer:
l = neuron.neuron(hiddenLayer, lamda)
l.setWeights()
lastNeurons.append(l)
for y in range(hiddenLayer):
lastNeurons[i].setInput(y+1, hiddenNeurons[y].getOutput())
lastNeurons[i].computeBaseFunction()
lastNeurons[i].computeOutput()
Err = 0
for i in range(lastLayer):#delta calculation for o/p layer
if i == int(k[0]):#check for which o/p neuron should give 1 as o/p
o=lastNeurons[i].getOutput()
Err = Err + (1 - o)**2
lastNeurons[i].setDelta( (1 - o) * lamda * o * (1 - o) )
else:
o=lastNeurons[i].getOutput()
Err = Err + (0 - lastNeurons[i].getOutput())**2
lastNeurons[i].setDelta( (0 - o) * lamda * o * (1 - o) )
TotalErr = TotalErr + 0.5 * Err
####Backpropagation
for i in range(hiddenLayer):
sum = 0
for sd in range(lastLayer):
sum = sum + lastNeurons[sd].getDelta() * lastNeurons[sd].getWeight(i+1)
#delta calc for hidden layer propagated from o/p layer
o=hiddenNeurons[i].getOutput()
hiddenNeurons[i].setDelta(sum * lamda * o * (1 - o))
for i in range(firstLayer):
sum = 0
for sd in range(hiddenLayer):
sum = sum+ hiddenNeurons[sd].getDelta() * hiddenNeurons[sd].getWeight(i+1)
#delta calc for hidden layer propagated from prev hidden layer
o=inputNeurons[i].getOutput()
inputNeurons[i].setDelta(sum * lamda * o * (1 - o))
for i in range(0, firstLayer):
for j in range(0, inputNeurons[i].getNumberInput()):
nw=inputNeurons[i].getWeight(j) + 0.6 * inputNeurons[i].getDelta() * inputNeurons[i].getInput(j)
inputNeurons[i].setWeight(j, nw)
for i in range(0, hiddenLayer):
for j in range(0, hiddenNeurons[i].getNumberInput()):
nw=hiddenNeurons[i].getWeight(j) + 0.6 * hiddenNeurons[i].getDelta() * hiddenNeurons[i].getInput(j)
hiddenNeurons[i].setWeight(j, nw)
for i in range(0, lastLayer):
for j in range(0, lastNeurons[i].getNumberInput()):
nw=lastNeurons[i].getWeight(j) + 0.6 * lastNeurons[i].getDelta() * lastNeurons[i].getInput(j)
lastNeurons[i].setWeight(j, nw)
import neuron as nr inputA = nr.neuron(1) inputB = nr.neuron(1) inputCi = nr.neuron(1) OrGate1 = nr.neuron([inputA, inputB], [1, 1], 1) NandGate1 = nr.neuron([inputA, inputB], [-1, -1], -1) XORGate1 = nr.neuron([OrGate1, NandGate1], [1, 1], 2) OrGate2 = nr.neuron([XORGate1, inputCi], [1, 1], 1) NandGate2 = nr.neuron([XORGate1, inputCi], [-1, -1], -1) XORGate2 = nr.neuron([OrGate2, NandGate2], [1, 1], 2) AndGate1 = nr.neuron([inputCi, XORGate1], [1, 1], 2) AndGate2 = nr.neuron([inputA, inputB], [1, 1], 2) OrGate3 = nr.neuron([AndGate1, AndGate2], [1, 1], 1) # print(OrGate3.getOutput(), XORGate2.getOutput()) print(OrGate3.getOutput() * 2 + XORGate2.getOutput())
def learning(learning_path, synapse):
#potentials of output neurons
potential_lists = []
for i in range(par.kSecondLayerNuerons_):
potential_lists.append([])
#time series
time_array = np.arange(1, par.kTime_+1, 1)
layer2 = []
# creating the hidden layer of neurons
for i in range(par.kSecondLayerNuerons_):
a = neuron()
layer2.append(a)
for epoch in range(1):
for wave_file in learning_path:
#for wave_file in ["sounddata\F1\F1SYB01_が.wav"]:
resemble_print(str(wave_file) + " " + str(epoch))
#音声データの読み込み
splited_sig_array, samplerate = wav_split(str(wave_file))
resemble_print(str(wave_file))
splited_sig_array = remove_silence(splited_sig_array)
print(len(splited_sig_array))
#スパイクの連結
#spike_train = wav_split2spike(splited_sig_array, samplerate)
#spike_connected = np.array(connect_spike(spike_train))
#for spike_train in spike_connected:
for signal in splited_sig_array:
#Generating melspectrum
f_centers, mel_spectrum = get_log_melspectrum(signal, samplerate)
#Generating spike train
spike_train = np.array(encode(np.log10(mel_spectrum)))
#calculating threshold value for the image
var_threshold = threshold(spike_train)
# resemble_print var_threshold
# synapse_act = np.zeros((par.kSecondLayerNuerons_,par.kFirstLayerNuerons_))
# var_threshold = 9
# resemble_print var_threshold
# var_D = (var_threshold*3)*0.07
var_D = 0.15 * par.kScale_
for x in layer2:
x.initial(var_threshold)
#flag for lateral inhibition
flag_spike = 0
img_win = 100
active_potential = []
for index1 in range(par.kSecondLayerNuerons_):
active_potential.append(0)
#Leaky integrate and fire neuron dynamics
for time in time_array:
for second_layer_position, second_layer_neuron in enumerate(layer2):
active = []
if(second_layer_neuron.t_rest < time):
second_layer_neuron.P = (second_layer_neuron.P
+ np.dot(
synapse[second_layer_position], spike_train[:, time]
)
)
#resemble_print("synapse : " + str(synapse[second_layer_position]))
if(second_layer_neuron.P > par.kPrest_):
second_layer_neuron.P -= var_D
active_potential[second_layer_position] = second_layer_neuron.P
potential_lists[second_layer_position].append(second_layer_neuron.P)
# Lateral Inhibition
if(flag_spike==0):
max_potential = max(active_potential)
if(max_potential > var_threshold):
flag_spike = 1
winner_neuron = np.argmax(active_potential)
img_win = winner_neuron
resemble_print("winner is " + str(winner_neuron))
for s in range(par.kSecondLayerNuerons_):
if(s != winner_neuron):
layer2[s].P = par.kMinPotential_
#Check for spikes and update weights
for second_layer_position, second_layer_neuron in enumerate(layer2):
neuron_status = second_layer_neuron.check()
if(neuron_status == 1):
second_layer_neuron.t_rest = time + second_layer_neuron.t_ref
second_layer_neuron.P = par.kPrest_
for first_layer_position in range(par.kFirstLayerNuerons_):
#前シナプスの計算
for back_time in range(-2, par.kTimeBack_-1, -1): #-2 → -20
if 0 <= time + back_time < par.kTime_ + 1:
if spike_train[first_layer_position][time + back_time] == 1:
# resemble_print "weight change by" + str(update(synapse[j][h], rl(t1)))
synapse[second_layer_position][first_layer_position] = update(
synapse[second_layer_position][first_layer_position], rl(back_time)
)
resemble_print("back : " + str(second_layer_position) + "-" + str(first_layer_position) + " : " + str(synapse[second_layer_position][first_layer_position]))
#後シナプスの計算
for fore_time in range(2, par.kTimeFore_+1, 1): # 2 → 20
if 0 <= time + fore_time<par.kTime_+1:
if spike_train[first_layer_position][time + fore_time] == 1:
# resemble_print "weight change by" + str(update(synapse[j][h], rl(t1)))
synapse[second_layer_position][first_layer_position] = update(
synapse[second_layer_position][first_layer_position], rl(fore_time)
)
resemble_print("fron : " + str(second_layer_position) + "-" + str(first_layer_position) + " : " + str(synapse[second_layer_position][first_layer_position]))
if(img_win!=100):
for first_layer_position in range(par.kFirstLayerNuerons_):
if sum(spike_train[first_layer_position]) == 0:
synapse[img_win][first_layer_position] -= 0.06 * par.kScale_
if(synapse[img_win][first_layer_position]<par.kMinWait_):
synapse[img_win][first_layer_position] = par.kMinWait_
return potential_lists, synapse, layer2
def winner_take_all(synapse, wave_file):
#potentials of output neurons
potential_lists = []
for i in range(par.kSecondLayerNuerons_):
potential_lists.append([])
#time series
time_array = np.arange(1, par.kTime_ + 1, 1)
layer2 = []
# creating the hidden layer of neurons
for i in range(par.kSecondLayerNuerons_):
a = neuron()
layer2.append(a)
neuron_spiked = np.zeros(par.kSecondLayerNuerons_)
for epoch in range(1):
resemble_print(str(wave_file) + " " + str(epoch))
#音声データの読み込み
#splited_sig_array, samplerate = wav_split(str(wave_file))
#resemble_print(wave_file)
splited_sig_array, samplerate = wav_split(str(wave_file))
resemble_print(str(wave_file))
#スパイクの連結
#spike_train = wav_split2spike(splited_sig_array, samplerate)
#spike_connected = np.array(connect_spike(spike_train))
#for spike_train in spike_connected:
for signal in splited_sig_array:
#Generating melspectrum
f_centers, mel_spectrum = get_log_melspectrum(signal, samplerate)
#Generating spike train
spike_train = np.array(encode(np.log10(mel_spectrum)))
#calculating threshold value for the image
var_threshold = threshold(spike_train)
# resemble_print var_threshold
# synapse_act = np.zeros((par.kSecondLayerNuerons_,par.kFirstLayerNuerons_))
# var_threshold = 9
# resemble_print var_threshold
# var_D = (var_threshold*3)*0.07
var_D = 0.15 * par.kScale_
for x in layer2:
x.initial(var_threshold)
#flag for lateral inhibition
flag_spike = 0
img_win = 100
active_potential = []
for index1 in range(par.kSecondLayerNuerons_):
active_potential.append(0)
#Leaky integrate and fire neuron dynamics
for time in time_array:
for second_layer_position, second_layer_neuron in enumerate(
layer2):
active = []
if (second_layer_neuron.t_rest < time):
second_layer_neuron.P = (
second_layer_neuron.P +
np.dot(synapse[second_layer_position],
spike_train[:, time]))
#resemble_print("synapse : " + str(synapse[second_layer_position]))
if (second_layer_neuron.P > par.kPrest_):
second_layer_neuron.P -= var_D
active_potential[
second_layer_position] = second_layer_neuron.P
potential_lists[second_layer_position].append(
second_layer_neuron.P)
# Lateral Inhibition
if (flag_spike == 0):
max_potential = max(active_potential)
if (max_potential > var_threshold):
flag_spike = 1
winner_neuron = np.argmax(active_potential)
img_win = winner_neuron
neuron_spiked[winner_neuron] += 1
resemble_print("winner is " + str(winner_neuron))
for s in range(par.kSecondLayerNuerons_):
if (s != winner_neuron):
layer2[s].P = par.kMinPotential_
#勝ったニューロンの特定
resemble_print(neuron_spiked)
return neuron_spiked
def create_list_of_neurons(size, start_label, layer_type, prev_layer_size, activation_function, learning_rate): l = [] for ii in range(0, size): l.append(neuron.neuron(start_label+ii, layer_type, prev_layer_size, activation_function, learning_rate)) return l
def learning(learning_or_classify):
#1 = learning, 0 = classify
#learning_or_classify = 0
print learning_or_classify
if(learning_or_classify == 0):
print "Starting classify..."
elif(learning_or_classify == 1):
print "Starting learning..."
else:
print "Error in argument, quitting"
quit()
if(learning_or_classify == 0):
par.epoch = 1
#potentials of output neurons
pot_arrays = []
pot_arrays.append([]) #because 0th layer do not require neuron model
for i in range(1,par.num_layers):
pot_arrays_this = []
for j in range(0,par.num_layer_neurons[i]):
pot_arrays_this.append([])
pot_arrays.append(pot_arrays_this)
print "created potential arrays for each layer..."
Pth_array = []
Pth_array.append([]) #because 0th layer do not require neuron model
for i in range(1,par.num_layers):
Pth_array_this = []
for j in range(0,par.num_layer_neurons[i]):
Pth_array_this.append([])
Pth_array.append(Pth_array_this)
print "created potential threshold arrays for each layer..."
train_all = []
for i in range(0,par.num_layers):
train_this = []
for j in range(0,par.num_layer_neurons[i]):
train_this.append([])
train_all.append(train_this)
print "created spike trains for each layer..."
#synapse matrix initialization
synapse = [] #synapse[i] is the matrix for weights from layer i to layer i+1, assuming index from 0
for i in range(0,par.num_layers-1):
synapse_this = np.zeros((par.num_layer_neurons[i+1],par.num_layer_neurons[i]))
synapse.append(synapse_this)
if(learning_or_classify == 1):
for layer in range(0,par.num_layers-1):
for i in range(par.num_layer_neurons[layer+1]):
for j in range(par.num_layer_neurons[layer]):
synapse[layer][i][j] = random.uniform(0,0.4*par.scale)
else:
for layer in range(0,par.num_layers-1):
for i in range(par.num_layer_neurons[layer+1]):
#for j in range(par.num_layer_neurons[layer]):
filename = "weights/layer_"+str(layer)+"_neuron_"+str(i)+".dat"
with open(filename,"rb") as f:
synapse[layer][i] = pickle.load(f)
print "created synapse matrices for each layer..."
#this contains neurons of all layers except first
layers = [] #layers[i] is the list of neurons from layer i, assuming index from 0
layer_this = []
layers.append(layer_this) #0th layer is empty as input layer do not require neuron model
#time series
time = np.arange(1, par.T+1, 1)
# creating each layer of neurons
for i in range(1,par.num_layers):
layer_this = []
for i in range(par.num_layer_neurons[i]):
a = neuron()
layer_this.append(a)
layers.append(layer_this)
print "created neuron for each layer..."
for k in range(par.epoch):
for i in range(1,7):
print "Epoch: ",str(k),", Image: ", str(i)
if(learning_or_classify == 1):
img = cv2.imread("training_images/" + str(i) + ".png", 0)
else:
img = cv2.imread("training_images/" + str(i) + ".png", 0)
#Convolving image with receptive field
pot = rf(img)
#print pot
#training layers i and i+1, assuming 0 indexing, thus n layers require n-1 pairs of training
for layer in range(0,par.num_layers-1):
print "Layer: ", str(layer)
#Generating spike train when the first layer
#else take the spike train from last layer
if(layer == 0):
train_all[layer] = np.array(encode(pot))
train = np.array(encode(pot))
else:
train_all[layer] = np.asarray(train_this_layer)
train = np.array(np.asarray(train_this_layer))
#print train[1]
#calculating threshold value for the image
var_threshold = threshold(train)
#print "var_threshold is ", str(var_threshold)
# print var_threshold
# synapse_act = np.zeros((par.n,par.m))
# var_threshold = 9
# print var_threshold
# var_D = (var_threshold*3)*0.07
var_D = 0.15*par.scale
for x in layers[layer+1]:
x.initial(var_threshold)
#flag for lateral inhibition
f_spike = 0
img_win = 100
active_pot = []
train_this_layer = []
for index1 in range(par.num_layer_neurons[layer+1]):
active_pot.append(0)
train_this_layer.append([])
#print synapse[layer].shape, train.shape
#Leaky integrate and fire neuron dynamics
for t in time:
#print "Time: ", str(t)
for j, x in enumerate(layers[layer+1]):
active = []
if(x.t_rest<t):
x.P = x.P + np.dot(synapse[layer][j], train[:,t])
if(x.P>par.Prest):
x.P -= var_D
active_pot[j] = x.P
#pot_arrays[layer+1][j].append(x.P)
#Pth_array[layer+1][j].append(x.Pth)
# Lateral Inhibition
# Occurs in the training of second last and last layer
#if(f_spike==0 and layer == par.num_layers - 2 and learning_or_classify == 1):
if(f_spike==0 ):
high_pot = max(active_pot)
if(high_pot>var_threshold):
f_spike = 1
winner = np.argmax(active_pot)
img_win = winner
#print "winner is " + str(winner)
for s in range(par.num_layer_neurons[layer+1]):
if(s!=winner):
layers[layer+1][s].P = par.Pmin
#Check for spikes and update weights
for j,x in enumerate(layers[layer+1]):
pot_arrays[layer+1][j].append(x.P)
Pth_array[layer+1][j].append(x.Pth)
s = x.check()
train_this_layer[j].append(s)
if(learning_or_classify == 1):
if(s==1):
x.t_rest = t + x.t_ref
x.P = par.Prest
for h in range(par.num_layer_neurons[layer]):
for t1 in range(-2,par.t_back-1, -1):
if 0<=t+t1<par.T+1:
if train[h][t+t1] == 1:
# print "weight change by" + str(update(synapse[j][h], rl(t1)))
synapse[layer][j][h] = update(synapse[layer][j][h], rl(t1))
for t1 in range(2,par.t_fore+1, 1):
if 0<=t+t1<par.T+1:
if train[h][t+t1] == 1:
# print "weight change by" + str(update(synapse[j][h], rl(t1)))
synapse[layer][j][h] = update(synapse[layer][j][h], rl(t1))
for j in range(par.num_layer_neurons[layer+1]):
train_this_layer[j].append(0)
#if(img_win!=100 and layer == par.num_layers - 2 ):
if(img_win!=100 ):
for p in range(par.num_layer_neurons[layer]):
if sum(train[p])==0:
synapse[layer][img_win][p] -= 0.06*par.scale
if(synapse[layer][img_win][p]<par.w_min):
synapse[layer][img_win][p] = par.w_min
#print train_this_layer
#print synapse[0][0]
train_all[par.num_layers-1] = np.asarray(train_this_layer)
results_each_layer = 1
if(results_each_layer):
for layer in range(par.num_layers-1,par.num_layers):
for i in range(par.num_layer_neurons[layer]):
print "Layer"+ str(layer) + ", Neuron"+str(i+1)+": "+str(sum(train_all[layer][i]))
#print classification results
# if(learning_or_classify == 0):
plot = 0
if (plot == 1):
for layer in range(par.num_layers-1,par.num_layers):
ttt = np.arange(0,len(pot_arrays[layer][0]),1)
#plotting
for i in range(par.num_layer_neurons[layer]):
axes = plt.gca()
axes.set_ylim([-20,50])
plt.plot(ttt,Pth_array[layer][i], 'r' )
plt.plot(ttt,pot_arrays[layer][i])
plt.show()
#Reconstructing weights to analyse training
reconst = 1
if(learning_or_classify != 1):
reconst = 0
if(reconst == 1):
for layer in range(par.num_layers-1):
siz_x = int(par.num_layer_neurons[layer]**(.5))
siz_y = siz_x
for i in range(par.num_layer_neurons[layer+1]):
reconst_weights(synapse[layer][i],i+1,layer,siz_x,siz_y)
#Dumping trained weights of last layer to file
dump = 1
if(learning_or_classify != 1):
dump = 0
if(dump == 1):
for layer in range(par.num_layers-1):
for i in range(par.num_layer_neurons[layer+1]):
filename = "weights/"+"layer_"+str(layer)+"_neuron_"+str(i)+".dat"
with open(filename,'wb') as f:
#f.write(str(synapse[layer][i]))
pickle.dump(synapse[layer][i],f)
