def main():
capture_layer = CaptureLayer()
input_layer = InputLayer()
control_layer = ControlLayer()
main_loop = True
capture_thread = Process(target=capture_layer.run_capture)
serial_thread = Process(target=serial_control)
capture_thread.start()
serial_thread.start()
last_busy = 1
while main_loop:
shape = capture_layer.marker_shape[:]
input_layer.update(shape, motor_busy.value)
control_layer.update(input_layer)
control_vector[0:3] = control_layer.get_control_vector()
if last_busy != motor_busy.value:
last_busy = motor_busy.value
print("BUSY" if motor_busy.value else "FREE")
if control_vector[1] != 0:
print("%d cm, %.1f deg" % (input_layer.distance_cm, input_layer.angle_deg)," "*8)
print("desired %d cm = %d steps" % (control_layer.desired_cm, control_vector[1]),
"conf: %.2f" % input_layer.distance_filter.confidence())
sleep(0.020)
def __init__(self, userid):
self.inputLayer = InputLayer()
self.hiddenLayers = []
self.outputLayer = OutputLayer()
self.userid = userid
self.outputs = []
def __init__(self, userid): self.inputLayer = InputLayer() self.hiddenLayers = [] self.outputLayer = OutputLayer() self.userid = userid self.outputs = []
def FullyConnectedLayerTest():
inputLayer = InputLayer(numInput + 1) # The +1 is the bias unit.
hiddenLayer = FullyConnectedLayer(numInput + 1, numHidden, nonlinear, nonlinearDeriv)
outputLayer = FullyConnectedLayer(numHidden, numOutput, nonlinear, nonlinearDeriv)
# Until we're done,
for i in xrange(numIterations):
# go through our samples:
for sample in samplesToProc:
inputs = sample[0:2]
# Do forward propagation on the sample.
inputOut = inputLayer.forward_prop(inputs)
hiddenOut = hiddenLayer.forward_prop(inputOut)
outOut = outputLayer.forward_prop(hiddenOut)
# Now, do backward propagation.
# Note that computation of weight deltas requires information outside of a layer.
outWeights = outputLayer.W
outDelta = sample[2] - outOut
outBack = outputLayer.backward_prop(hiddenOut, outDelta, learningRate)
hiddenDelta = np.dot(outWeights, outBack) # Needs weights of output layer BEFORE update!
hiddenBack = hiddenLayer.backward_prop(inputOut, hiddenDelta, learningRate)
# Print the current error we're experiencing.
if i % 100 == 0:
print "error on iteration %d: %0.3f" % (i, Error(sample[2], outOut)[0])
# Print our final values.
print "FINAL VALUES:"
for sample in samplesToProc:
inputs = sample[0:2]
print "input: ", inputs
# Get the final value.
inputOut = inputLayer.forward_prop(inputs)
hiddenOut = hiddenLayer.forward_prop(inputOut)
outOut = outputLayer.forward_prop(hiddenOut)
# Print final along with expected, and error.
print "output: ", outOut
print "expected output: ", sample[2]
print "error: %0.2f" % Error(sample[2], outOut)[0]
def __init__(self, train_x, train_y, test_x, test_y):
self.train_x = train_x
self.train_y = train_y
self.test_x = test_x
self.test_y = test_y
self.preprocess()
self.input_layer = InputLayer(self.train_x.shape[1])
self.output_layer = OutputLayer(len(self.train_y), self.input_layer)
self.input_layer.prev_layer = self.output_layer
self.accuracy = 0
self.loss = 0
self.add_layer(LayerDense(self.train_x.shape[1], 64))
self.add_layer(LayerDense(64, 32))
self.add_layer(LayerDense(32, len(self.train_y)))
self.optimizer = OptimizerAdam(learning_rate=0.05, decay=5e-7)
def build_neural_network(opencl_context, inputs, targets, layers,
learning_rate, regulization):
input_layer = InputLayer(inputs, opencl_context)
model_layers = []
model_layers.append(input_layer)
for i in range(len(layers) - 1):
layer = Layer(layers[i], np.tanh, learning_rate, regulization,
opencl_context)
layer.link_prev(model_layers[-1])
model_layers.append(layer)
#add output layer
layer = Layer(layers[-1], np.exp, learning_rate, regulization,
opencl_context)
layer.link_prev(model_layers[-1])
model_layers.append(layer)
return model_layers
def __init__(self,
layers,
l2_decay=0.001,
debug=False,
learning_rate=0.001):
super(Network, self).__init__()
mapping = {
"input": lambda x: InputLayer(x),
"fc": lambda x: FullyConnectedLayer(x),
"convolution": lambda x: ConvLayer(x),
"pool": lambda x: MaxPoolLayer(x),
"squaredloss": lambda x: SquaredLossLayer(x),
"softmax": lambda x: SoftmaxLayer(x),
"relu": lambda x: ReLULayer(x),
"dropout": lambda x: DropoutLayer(x)
}
self.layers = []
self.l2_decay = l2_decay
self.debug = debug
self.learning_rate = learning_rate
def __init__(self, n_input, n_output):
self.input_layer = InputLayer(n_input)
self.output_layer = OutputLayer(n_output, self.input_layer)
self.input_layer.prev_layer = self.output_layer
self.accuracy = 0
self.loss = 0
class ANN:
def __init__(self, userid):
self.inputLayer = InputLayer()
self.hiddenLayers = []
self.outputLayer = OutputLayer()
self.userid = userid
self.outputs = []
def init(self, layers_data):
self.layers_data = layers_data
for i in range(1, len(layers_data) - 1):
self.hiddenLayers.append(HiddenLayer())
self.hiddenLayers[-1].init(layers_data[i - 1] + 1, layers_data[i])
self.outputLayer.init(layers_data[-2] + 1, layers_data[-1])
"""self.hiddenLayers[0].neurons[0].weights = [0.5, 0.4, -0.8]
self.hiddenLayers[0].neurons[1].weights = [0.9, 1.0, 0.1]
self.outputLayer.neurons[0].weights = [-1.2, 1.1, -0.3]"""
self.outputs = [0 for i in range(layers_data[-1])]
def activate(self, input_data):
self.inputLayer.init(input_data)
self.hiddenLayers[0].activate(self.inputLayer.data)
for i in range(1, len(self.hiddenLayers)):
self.hiddenLayers[i].activate(self.hiddenLayers[i - 1].outputs)
self.outputLayer.activate(self.hiddenLayers[-1].outputs)
self.outputs = self.outputLayer.outputs
def updateErrorGradients(self, desiredOutputs):
sum_errors = self.outputLayer.updateErrorGradients(desiredOutputs)
self.hiddenLayers[-1].updateErrorGradients(self.outputLayer)
for i in range(len(self.hiddenLayers) - 2, -1, -1):
self.hiddenLayers[i].updateErrorGradients(self.hiddenLayers[i + 1])
return sum_errors
def updateWeights_slope(self):
self.hiddenLayers[0].updateWeights_slope(self.inputLayer.data)
for i in range(1, len(self.hiddenLayers)):
self.hiddenLayers[i].updateWeights_slope(
self.hiddenLayers[i - 1].outputs)
self.outputLayer.updateWeights_slope(self.hiddenLayers[-1].outputs)
def updateWeights(self):
for i in range(len(self.hiddenLayers)):
self.hiddenLayers[i].updateWeights()
self.outputLayer.updateWeights()
def saveData(self):
data = []
data.append(self.layers_data)
for h in self.hiddenLayers:
for n in h.neurons:
data.append(n.weights)
for n in self.outputLayer.neurons:
data.append(n.weights)
if not models.Ann_net_data.objects.filter(userid=self.userid):
models.Ann_net_data.objects.create(userid=self.userid,
data=str(data))
else:
models.Ann_net_data.objects.filter(userid=self.userid).update(
data=str(data))
del data
return
### save neurons data
data = []
for h in self.hiddenLayers:
for n in h.neurons:
data.append(n.weights_slope_prev)
data.append(n.deltha)
for n in self.outputLayer.neurons:
data.append(n.weights_slope_prev)
data.append(n.deltha)
if not models.Ann_trainer_rp_data.objects.filter(userid=self.userid):
models.Ann_trainer_rp_data.objects.create(userid=self.userid,
nrndata=str(data))
else:
models.Ann_trainer_rp_data.objects.filter(
userid=self.userid).update(nrndata=str(data))
del data
def loadData(self):
return False
if not models.Ann_net_data.objects.filter(userid=self.userid):
return False
if not models.Ann_trainer_rp_data.objects.filter(userid=self.userid):
return False
### load net data
data = eval(models.Ann_net_data.objects.get(userid=self.userid).data)
self.init(data[0])
index = 1
for h in self.hiddenLayers:
for n in h.neurons:
n.weights = data[index]
index += 1
for n in self.outputLayer.neurons:
n.weights = data[index]
index += 1
del data
### load neurons data
data = eval(
models.Ann_trainer_rp_data.objects.get(userid=self.userid).nrndata)
index = 0
for h in self.hiddenLayers:
for n in h.neurons:
n.weights_slope_prev = data[index]
n.deltha = data[index + 1]
index += 2
for n in self.outputLayer.neurons:
n.weights_slope_prev = data[index]
n.deltha = data[index + 1]
index += 2
del data
return True
def __str__(self):
result = ""
result += "----------------->input layer :\n" + str(
self.inputLayer) + '\n'
for h in self.hiddenLayers:
result += "----------------->hidden layer :\n" + str(h) + '\n'
result += "----------------->output layer :\n" + str(
self.outputLayer) + '\n'
result += "----------------->outputs :\n" + str(self.outputs)
return result
round((random.uniform(0.4, 0.6)), 5) for _ in range(QUANTITY_INPUT)
]
weight_relation_vector.append(t)
return weight_relation_vector
if __name__ == '__main__':
epoch = 10
size_sample = 100
quantity_cluster = 5
output_layer = OutputLayer(form_weight_relation(quantity_cluster),
quantity_cluster)
input_layer = InputLayer(form_sample(size_sample),
output_layer,
size_sample=size_sample)
help_epoch = []
help_function = []
speed_function_start = 0.5
delta_function_start = 0.5
for i in range(epoch):
delta_function = (-i / (epoch + 1) + 1)
#delta_function = 1
speed_function = speed_function_start * e**(i / epoch)
k = input_layer.epoch(output_layer.weight_relation_vector,
output_layer.quantity_cluster, delta_function,
speed_function)
def __init__(self, num_units):
self.layers = [InputLayer(num_units)]
class ANN: def __init__(self, userid): self.inputLayer = InputLayer() self.hiddenLayers = [] self.outputLayer = OutputLayer() self.userid = userid self.outputs = [] def init(self, layers_data): self.layers_data = layers_data for i in range(1, len(layers_data) - 1): self.hiddenLayers.append(HiddenLayer()) self.hiddenLayers[-1].init(layers_data[i - 1] + 1, layers_data[i]) self.outputLayer.init(layers_data[-2] + 1, layers_data[-1]) """self.hiddenLayers[0].neurons[0].weights = [0.5, 0.4, -0.8] self.hiddenLayers[0].neurons[1].weights = [0.9, 1.0, 0.1] self.outputLayer.neurons[0].weights = [-1.2, 1.1, -0.3]""" self.outputs = [0 for i in range(layers_data[-1])] def activate(self, input_data): self.inputLayer.init(input_data) self.hiddenLayers[0].activate(self.inputLayer.data) for i in range(1, len(self.hiddenLayers)): self.hiddenLayers[i].activate(self.hiddenLayers[i - 1].outputs) self.outputLayer.activate(self.hiddenLayers[-1].outputs) self.outputs = self.outputLayer.outputs def updateErrorGradients(self, desiredOutputs): sum_errors = self.outputLayer.updateErrorGradients(desiredOutputs) self.hiddenLayers[-1].updateErrorGradients(self.outputLayer) for i in range(len(self.hiddenLayers) - 2, -1, -1): self.hiddenLayers[i].updateErrorGradients(self.hiddenLayers[i + 1]) return sum_errors def updateWeights(self, learningRate): self.hiddenLayers[0].updateWeights(self.inputLayer.data, learningRate) for i in range(1, len(self.hiddenLayers)): self.hiddenLayers[i].updateWeights(self.hiddenLayers[i - 1].outputs, learningRate) self.outputLayer.updateWeights(self.hiddenLayers[-1].outputs, learningRate) def saveData(self): data = [] data.append(self.layers_data) for h in self.hiddenLayers: for n in h.neurons: data.append(n.weights) for n in self.outputLayer.neurons: data.append(n.weights) if not models.Ann_net_data.objects.filter(userid=self.userid): models.Ann_net_data.objects.create(userid=self.userid, data=str(data)) else: models.Ann_net_data.objects.filter(userid=self.userid).update(data=str(data)) del data def loadData(self): if not models.Ann_net_data.objects.filter(userid=self.userid): return data = eval(models.Ann_net_data.objects.get(userid=self.userid).data) self.init(data[0]) index = 1 for h in self.hiddenLayers: for n in h.neurons: n.weights = data[index] index += 1 for n in self.outputLayer.neurons: n.weights = data[index] index += 1 del data return True def __str__(self): result = "" result += "----------------->input layer :\n" + str(self.inputLayer) + '\n' for h in self.hiddenLayers: result += "----------------->hidden layer :\n" + str(h) + '\n' result += "----------------->output layer :\n" + str(self.outputLayer) + '\n' result += "----------------->outputs :\n" + str(self.outputs) return result
}
graph = topological_sort(feed_dict)
output = forward_pass(f, graph)
logging.info(output)
print(output)
# Layer
import numpy as np
from input_layer import InputLayer
from linear_layer import LinearLayer
from helper_layer import *
print("Layer Linear Transform")
inputs, weights, bias = InputLayer(), InputLayer(), InputLayer()
f = LinearLayer(inputs, weights, bias)
x = np.array([[-1., -2.], [-1, -2]])
w = np.array([[2., -3], [2., -3]])
b = np.array([-3., -5])
feed_dict = {inputs: x, weights: w, bias: b}
graph = topological_sort_layer(feed_dict)
output = forward_pass_layer(f, graph)
logging.info(output)
print(output)
# Sigmoid
from sigmoid import Sigmoid
class ANN: def __init__(self, userid): self.inputLayer = InputLayer() self.hiddenLayers = [] self.outputLayer = OutputLayer() self.userid = userid self.outputs = [] def init(self, layers_data): for i in range(1, len(layers_data) - 1): self.hiddenLayers.append(HiddenLayer()) self.hiddenLayers[-1].init(layers_data[i - 1] + 1, layers_data[i]) self.outputLayer.init(layers_data[-2] + 1, layers_data[-1]) """self.hiddenLayers[0].neurons[0].weights = [0.5, 0.4, -0.8] self.hiddenLayers[0].neurons[1].weights = [0.9, 1.0, 0.1] self.outputLayer.neurons[0].weights = [-1.2, 1.1, -0.3]""" self.outputs = [0 for i in range(layers_data[-1])] def activate(self, input_data): self.inputLayer.init(input_data) self.hiddenLayers[0].activate(self.inputLayer.data) for i in range(1, len(self.hiddenLayers)): self.hiddenLayers[i].activate(self.hiddenLayers[i - 1].outputs) self.outputLayer.activate(self.hiddenLayers[-1].outputs) self.outputs = self.outputLayer.outputs def loadData(self): if not models.Ann_net_data.objects.filter(userid=self.userid): return data = eval(models.Ann_net_data.objects.get(userid=self.userid).data) self.init(data[0]) index = 1 for h in self.hiddenLayers: for n in h.neurons: n.weights = data[index] index += 1 for n in self.outputLayer.neurons: n.weights = data[index] index += 1 del data def __str__(self): result = "" result += "----------------->input layer :\n" + str(self.inputLayer) + '\n' for h in self.hiddenLayers: result += "----------------->hidden layer :\n" + str(h) + '\n' result += "----------------->output layer :\n" + str(self.outputLayer) + '\n' result += "----------------->outputs :\n" + str(self.outputs) return result
from neural_network import NeuralNetwork
from input_layer import InputLayer
from output_layer import OutputLayer
from hidden_layer import HiddenLayer
# test train xor function
model = NeuralNetwork(InputLayer(2), HiddenLayer(2, "sigmoid"),
OutputLayer(1, "sigmoid"))
train_input = [[1, 1], [1, 0], [0, 1], [0, 0]]
train_output = [0, 1, 1, 0]
model.train(train_input, train_output, 1, 0.1, 20)
model.predict([1, 1])
model.predict([1, 0])
model.predict([0, 1])
model.predict([0, 0])
