def propagate_input(self, values):
"""
takes input values, forward propagates them through the network
and returns the activation values for the output layer
"""
assert self.connections is not None
assert len(values) == self.n_regular_neurons[0]
self.set_layer(0, np.array(values))
for layer_no in xrange(len(self.n_regular_neurons) - 1):
a = self.neuron_layers[layer_no]
b = self.connections[layer_no]
self.set_layer(layer_no + 1, self.vector_activation_function(a.dot(b)))
return self.neuron_layers[-1]
if __name__ == '__main__':
# number of normal neurons per layer
layers = [3, 5, 2]
# values of any bias neurons in the key layer
bias = {0: [1.0]}
nn = NeuralNetwork(layers, bias)
nn.connections = [random_matrix(a, b) for (a, b) in nn.get_matrix_dimensions()]
nn.propagate_input([1, 0, 1])
if order <= 0:
message = "{} is not a positive integer".format(value)
raise ArgumentTypeError(message)
return order
if __name__ == '__main__':
parser = ArgumentParser(description='Plane curves recognizer')
parser.add_argument('-n', '--order',
type=check_positive_integer, default=2,
help='order of curve to recognize')
parser.add_argument('-t', '--interval',
type=check_positive_integer, default=200,
help='interval of screen refresh')
args = parser.parse_args()
order = args.order + 1
interval = args.interval
#A = None
#while not is_positive_definite(A):
# A = get_product_matrix(random_matrix(order*2, order*2) - .5)
A = get_product_matrix(random_matrix(order*2, order*2) - .5)
#pring 'Parameters:', A
perceptron = Perceptron((order*2)**2)
curve = CurveExample(perceptron, A,
(inside_x_points, inside_y_points),
(outside_x_points, outside_y_points),
order, LIMITS_X, LIMITS_Y, RESOLUTION)
run_animation(curve, interval)
RESOLUTION = 100
POLY_ORDER = 3
fig = plt.figure()
ax = plt.axes(xlim=LIMITS_X, ylim=LIMITS_Y)
inside_x_points = []
inside_y_points = []
outside_x_points = []
outside_y_points = []
A = random_matrix(POLY_ORDER*2, POLY_ORDER*2) - .5
def get_poly(x):
return ([1] + [x**i for i in range(1, POLY_ORDER)])[::-1]
def get_vector(x, y):
return array(get_poly(x) + get_poly(y))
def get_eq(x, y, A):
v = get_vector(x, y)
return v.dot(A).dot(v)
inside, = ax.plot([], [], 'ro')
outside, = ax.plot([], [], 'bo')
perceptron = Perceptron((POLY_ORDER*2)**2)
x = linspace(LEFT_X, RIGHT_X, RESOLUTION)
