def test_updateWeights(self):
weights1 = tf.constant([4, 5, 6])
target = Neuron(weights1, 7)
tf.debugging.assert_equal(target._weights, weights1)
weights2 = tf.constant([8, 9, 10])
target.updateWeights(weights2)
tf.debugging.assert_equal(target._weights, weights2)
def generate_random(self, count, layer_size=3):
for i in range(count):
if random.randrange(0, 10) == 5:
self.connect(
self.add_neuron(
Neuron(random.uniform(0.1, 0.3), random.uniform(0.6, 1.2), random.uniform(0.2, 0.7))),
self.get_rand_neurons(random.randrange(1, layer_size), len(self.neurons)))
else:
self.connect(self.add_neuron(ResistNeuron(random.uniform(0.7, 1.1), random.uniform(0.9, 1.5))),
self.get_rand_neurons(random.randrange(1, layer_size), len(self.neurons)))
def __init__(self):
## @var neurons
# List of neurons in the structure
self.neurons = [Neuron() for index in range(10)]
## @var carry_over
# Boolean variable. True signals a carry over.
self.carry_over = False
## @var index
# Structure index. Points to one of the ten neurons in the structure.
self.index = 0
def __init__(self):
self.rs = RS_232(wrk_dir='/tmp/Cortix', filename='ir_7040')
self.neuron = Neuron(task=self.rs.ir_7040,wrk_dir='/tmp/Cortix',name='ir_7040')\
self.socket_list = []
self.init_port = 60000
self.port = 60001
#self.host= str(socket.gethostbyname(socket.gethostname()))
self.host = '10.253.90.99'
print(self.host)
def test_init(self):
weights = tf.constant([1, 2, 3])
bias = tf.constant(4)
target = Neuron(weights, bias)
tf.debugging.assert_equal(target._weights, weights)
tf.debugging.assert_equal(target.weights, weights)
tf.debugging.assert_equal(target._bias, bias)
tf.debugging.assert_equal(target.bias, bias)
def loadptcs(self):
"""Load neurons from a single .ptcs file"""
self.header = PTCSHeader()
with open(self.path, 'rb') as f:
self.header.read(f)
for i in range(self.header.nneurons):
neuron = Neuron(self.path, sort=self)
neuron.loadptcs(f, self.header)
self.alln[neuron.id] = neuron # save it
assert eof(f), 'File %s has unexpected length' % self.path
def __init__(self, num_neurons, bias):
# Every neuron in a layer shares the same bias 一层中的所有神经元共享一个bias
self.bias = bias if bias else random.random()
random.random()
# 生成0和1之间的随机浮点数float，它其实是一个隐藏的random.Random类的实例的random方法。
# random.random()和random.Random().random()作用是一样的。
self.neurons = []
for i in range(num_neurons):
self.neurons.append(Neuron(self.bias))
def __init__(self, layer_indx):
'''
Constructor
'''
self.layer_indx = layer_indx
# create neurons
self.neurons = []
# if input layer
if (layer_indx == 0):
for k in range(0, varis.x.shape[0]):
numOf_weights = 0
neuron = Neuron(numOf_weights)
self.neurons.append(neuron)
# if middle layers
elif (layer_indx <= varis.hidden_layers):
if (layer_indx == 1):
# first hidden layer
# +1 for bias weight
numOf_weights = varis.x.shape[0] + 1
neuron = Neuron(numOf_weights)
self.neurons.append(neuron)
else:
# rest of the layers
for k in range(0, varis.hidden_neurons):
# +1 for bias weight
numOf_weights = varis.hidden_neurons + 1
neuron = Neuron(numOf_weights)
self.neurons.append(neuron)
# if last layer
else:
for k in range(0, varis.y.shape[0]):
numOf_weights = varis.hidden_neurons
neuron = Neuron(numOf_weights)
self.neurons.append(neuron)
def __init__(self,
nbNeurons=5,
nbConnexions=5,
nbInputsNeurons=2,
nbOutputsNeurons=1,
genes=None):
self.fitness = 0.0
if (genes != None):
neuronGenes = genes[0]
connexionGenes = genes[1]
# print(neuronGenes)
# print(connexionGenes)
self.nbNeurons = 0
self.neuronList = []
self.inputNeuronList = []
self.outputNeuronList = []
self.connexionList = []
for neuronGene in neuronGenes:
neuron = None
if neuronGene[1] == 'n':
neuron = Neuron(self.nbNeurons, bias=neuronGene[0])
elif neuronGene[1] == 'i':
neuron = InputNeuron(self.nbNeurons, bias=neuronGene[0])
self.inputNeuronList.append(neuron)
elif neuronGene[1] == 'o':
neuron = OutputNeuron(self.nbNeurons, bias=neuronGene[0])
self.outputNeuronList.append(neuron)
self.neuronList.append(neuron)
self.nbNeurons += 1
for connGene in connexionGenes:
fromNeuron = self.neuronList[connGene[0]]
toNeuron = self.neuronList[connGene[1]]
self.connexionList.append(
Connexion(fromNeuron, toNeuron, connGene[2]))
self.nbConnexions = len(self.connexionList)
self.species = str(self.nbNeurons) + "_" + str(self.nbConnexions)
else:
self.nbNeurons = 0
self.neuronList = []
self.inputNeuronList = []
self.outputNeuronList = []
self.nbConnexions = 0
self.connexionList = []
self.species = str(self.nbNeurons) + "_" + str(self.nbConnexions)
for idInputNeuron in range(nbInputsNeurons):
self.createNeuron("input")
for idNeuron in range(nbNeurons - nbInputsNeurons -
nbOutputsNeurons):
self.createNeuron()
for idOutputNeuron in range(nbOutputsNeurons):
self.createNeuron("output")
for idConnexion in range(nbConnexions):
self.createConnexion()
self.clean()
def initilize(self):
weight_num = self.inputNum
for i in range(self.hiddenLayerNum):
self.layers.append(Neuron(weight_num, self.neuronNum[i]))
weight_num = self.neuronNum[i]
#self.deltes.append(list(temp2))
for i in range(self.hiddenLayerNum):
Y = np.zeros(self.neuronNum[i])
Y2 = np.zeros(self.neuronNum[i])
Neuron.neuron_ouput.append(Y)
Neuron.neuron_deltes.append(Y2)
def __init__(self, learning_rate: float = 0.1, activation_function: callable = None):
self._learning_rate = learning_rate
self.activation_function = activation_function
self.neuron = Neuron(learning_rate, activation_function)
self.list_sources_target = []
self.cycles = 0
self.total_square_error_by_cycle = []
def test1():
test_neuron = Neuron(3)
test_layer = Layer(3, 0)
test_layer.neurons[0].alpha = 0
test_layer.neurons[1].alpha = 1
test_layer.neurons[2].alpha = 0
test_neuron.weights[0] = 1
test_neuron.weights[1] = 1
test_neuron.weights[2] = 1
print("This should print out 0.73:")
print(sig_func(test_neuron, test_layer))
def addLayer(self, layerSize):
self.NetworkStruct.append([])
for i in range(layerSize):
self.NetworkStruct[-1].append(
Neuron(len(self.NetworkStruct), i + 1))
#weights[second layer number, position of 1st neuron on last layer, position of 2nd neuron on current layer]
self.weights.append([])
for i in range(len(self.NetworkStruct[-2])):
self.weights[-1].append([])
for _ in range(len(self.NetworkStruct[-1])):
self.weights[-1][-1].append(.5)
def createNeuron(self, *args, **keywordArgs):
"""
Create a new neuron.
>>> neuron = network.createNeuron(name = 'AVAL')
Returns the :class:`neuron <Network.Neuron.Neuron>` that is created.
"""
neuron = Neuron(self, *args, **keywordArgs)
self.addObject(neuron)
return neuron
def build_custom_layer(prev_layer_size, layer_size):
new_layer = []
for _ in range(layer_size):
new_neuron = Neuron()
weights = []
for _ in range(prev_layer_size):
weights.append(random.random() * 2 - 1)
new_neuron.set_weights(weights)
new_neuron.set_bias(random.random() * 2 - 1)
new_layer.append(new_neuron)
return new_layer
def __init__(self, num_neurons, act):
""" Constructs a Neural Layer
num_neurons: number of Neurons width of layer
act: layer activation function
"""
self.num_neurons = num_neurons
self.neurons = []
for i in range(self.num_neurons):
neuron = Neuron(act=act)
self.neurons.append(neuron)
def __init__(self, input_count, hidden_neurons, output_neurons):
"""Creates and initializes the neural network.
`input_count` -- The number of inputs for this network.
`hidden_neurons` -- A 2-d list of `NeuronInfo` instances. Each row represents a hidden layer.
The layers can be of different lenghts.
`output_neurons` -- a 1-d list of `NeuronInfo` instances. This represents output neurons.
"""
# Initialize the input layer. The last element of the all layers will be the bias neuron.
self.__input_layer = [InputNeuron() for i in range(input_count)] + [BiasNeuron()]
# Initialize the hidden layers.
self.__hidden_layers = []
last_layer = self.__input_layer
for infos in hidden_neurons:
# The last element of the all layers will be the bias neuron.
layer = [Neuron(last_layer, info.weights, info.activation_function, info.activation_function_derivative) for info in infos] + [BiasNeuron()]
last_layer = layer
self.__hidden_layers.append(layer)
# Initialize the output layer.
self.__output_layer = [Neuron(last_layer, info.weights, info.activation_function, info.activation_function_derivative) for info in output_neurons]
def __init__(self, num_neurons, num_inputs, activation, derivative):
"""
Initializes a layer of neurons
@param (Number) num_neurons - The number of neurons in the layer
@param (Number) num_inputs - The number of inputs of each neuron in the layer
@param (Function) activation - The activation function to be used
@param (Function) derivative - The derivative of the activation function
@returns (Layer)
"""
self.neurons = [
Neuron(num_inputs, activation, derivative)
for i in range(0, num_neurons, 1)
]
def __init__(self, neuronCount, minBias, maxBias, minWeight, maxWeight):
self.neurons = [[]]
for j in range(len(neuronCount) - 1, -1, -1):
amount = neuronCount[j]
for i in range(amount):
# First go, output neurons
if j == len(neuronCount) - 1:
self.neurons[0].append(
Neuron(f"{j},{i}", random.uniform(minBias, maxBias),
[]))
else:
nextLayer = []
if j != len(neuronCount) - 1:
for neuron in self.neurons[len(neuronCount) - 2 - j]:
nextLayer.append(
Connection(
neuron,
random.uniform(minWeight, maxWeight)))
if len(self.neurons) > len(neuronCount) - 1 - j:
if j == 0:
self.neurons[len(neuronCount) - 1 - j].append(
Neuron(f"{j},{i}", 0, nextLayer))
else:
self.neurons[len(neuronCount) - 1 - j].append(
Neuron(f"{j},{i}",
random.uniform(minBias, maxBias),
nextLayer))
else:
if j == 0:
self.neurons.append(
[Neuron(f"{j},{i}", 0, nextLayer)])
else:
self.neurons.append([
Neuron(f"{j},{i}",
random.uniform(minBias, maxBias),
nextLayer)
])
self.neurons = self.neurons[::-1]
def createNeuron(self, type="norm"):
if type == "input":
neuron = InputNeuron(self.nbNeurons)
self.neuronList.append(neuron)
self.inputNeuronList.append(neuron)
elif type == "output":
neuron = OutputNeuron(self.nbNeurons)
self.neuronList.append(neuron)
self.outputNeuronList.append(neuron)
else:
neuron = Neuron(self.nbNeurons)
self.neuronList.append(neuron)
self.nbNeurons += 1
def __init__(self, hiddenActivation="sigmoid"):
# activation function for hidden layer
self.hiddenActivation = hiddenActivation
# Select appropriate weight initialization for activation function
if self.hiddenActivation == "sigmoid":
init_technique = "xavier"
elif self.hiddenActivation in ["ReLU", "leaky ReLU"]:
init_technique = "he"
else:
raise Exception("Activation for hidden layer not recognized")
# create hidden layer with 5 neurons
self.hidden = [
Neuron(initialize(init_technique, 11, 3, 11), 0,
self.hiddenActivation) for i in range(5)
]
# create a softmax layer with 3 neurons
self.soft = [
Neuron(initialize("xavier", 5, 1, 5), 0, None) for i in range(3)
]
def decide_trucada(self, hand):
cards_in_hand_weight = self.cards_weight(self.cards_in_hand)
cards_in_hand_mean = cards_in_hand_weight / len(self.cards_in_hand)
entries_choice = [[
self.who_made_first,
self.cards_weight(self.opponent_cards_played), cards_in_hand_mean,
hand
]]
choice_neuron = Neuron(entries_choice).exec()
if round(choice_neuron) == 1:
return ('r', 1)
else:
return ('r', 2)
def init_neurons(self):
for layer_ix, layer_size in enumerate(self.initial_topology):
layer = []
if layer_ix == 0:
_type = 'input'
elif layer_ix == len(self.initial_topology) - 1:
_type = 'output'
else:
_type = 'hidden'
for _ in range(layer_size):
neuron = Neuron(_type)
layer.append(neuron)
self.layers.append(layer)
def __init__(self, num_in, num_out, *num_hidden):
self.num_in = num_in
self.num_out = num_out
self.num_hidden = num_hidden
self.num_layers = 2 + len(num_hidden)
# Neuron array l, n
self.layers = []
self.bias = []
# setup neurons in layers array
for l in range(self.num_layers):
if l == 0:
layer = [RestrictedNeuron() for x in range(self.num_in)]
self.layers.append(layer)
elif l == self.num_layers - 1:
layer = [Neuron() for x in range(self.num_out)]
self.layers.append(layer)
else:
layer = [Neuron() for x in range(self.num_hidden[l - 1])]
self.layers.append(layer)
# setup restricted neurons in bias array
for l in range(self.num_layers - 1):
self.bias.append(RestrictedNeuron())
# setup connections
for l in range(self.num_layers - 1, 0,
-1): # start at final index / output layer
k_layer = self.layers[l]
n_layer = self.layers[l - 1]
n_bias_neuron = RestrictedNeuron()
for k_neuron in k_layer:
for n_neuron in n_layer:
k_neuron.add_inbound_connection(n_neuron)
k_neuron.add_inbound_connection(n_bias_neuron)
def __init__(self, net_config):
for i in range(len(net_config)):
self.net.append([])
if i == 0: funtion_title = 'linear'
else: funtion_title = 'threshold'
neuron = Neuron(i, funtion_title)
for j in range(net_config[i]):
self.net[i].append(neuron)
for i in range(len(net_config) - 1):
self.weight.append([])
for j in range(len(self.net[i])):
self.weight[i].append([])
for k in range(len(self.net[i + 1])):
self.weight[i][j].append(uniform(.1, .4))
def __init__(self, neuron_setup, x_dim=5, y_dim=5):
"""
Constructor of the base layer. A base layer is a flat 2D layer with
neurons of a given model (parameters) and built-in spike detector.
:param neuron_setup: NeuronSetup object with settings for the
neurons for the layer
:param x_dim: number of neurons in X-dimension
:param y_dim: number of neurons in Y-dimension
"""
self._x_dim = x_dim
self._y_dim = y_dim
self._neurons = [Neuron(neuron_setup) for i in range(x_dim * y_dim)]
def __init__(self, n_input, n_output):
"""
Creates a new sigmoid network
parameters:
n_input - int, number of input variables
n_output - int, number of output variables (classes)
"""
self._n_output = n_output
self._n_input = n_input
#initializes the neurons for the output classes
self._neurons = [Neuron(n_input) for _ in range(n_output)]
def addNeuron(self, spikeAmplitude, spikeAmplitude2, exciteTimeConstant,
inhibTimeConstant, designation, delay1, delay2,
wantBGCurrent):
'''
# Adds a single neuron to the network
# It also automatically adds a section for itself in the adjacency matrix
'''
iD = len(self.listOfNeurons)
neuron = Neuron(spikeAmplitude, spikeAmplitude2, exciteTimeConstant,
inhibTimeConstant, designation, iD, delay1, delay2,
wantBGCurrent, self.networkID)
neuron.setTime(self.timeStep, self.duration, self.resolution)
self.listOfNeurons.append(neuron)
self.adjacencyMatrix.addNeuron()
def __init__(self, size):
preneurons = []
defaultweight = 0.3
#create neurons
for i in range(size):
tempneuron = Neuron('sensory' + str(i), 'inputneuron', actthreshold)
preneurons.append(tempneuron)
self.neurons = preneurons
self.size = size
#connect neurons
for neuron1 in self.neurons:
for neuron2 in self.neurons:
if neuron1 is not neuron2:
neuron1.add_inconnects([neuron2, defaultweight])
neuron2.add_outconnects([neuron1, defaultweight])
def simulate(self, process):
# parallel processing on each setting value
self.pid = os.getpid()
self.progress_co = 0
self.nr = Neuron(**self.parm[process + self.multiproc_co])
self.nr.parm_dict = self.parm[process + self.multiproc_co]
for i in range(0, self.nr.allsteps - 1):
self.nr.propagation()
if self.progress_co % 100000 == 0:
logging.warning('process id : %d : %4d steps', self.pid,
self.progress_co)
self.progress_co += 1
return self.nr
