def test_multiple_outputs(self):
input_data = np.array([
[-0.1961, 0.9806],
])
input_size, output_size = (2, 3)
input_layer = layers.StepLayer(
input_size,
weight=np.array([
[0.7071, 0.7071, -1],
[-0.7071, 0.7071, 0],
])
)
output_layer = layers.CompetitiveOutputLayer(output_size)
hamming_network = algorithms.Instar(
input_layer > output_layer,
step=0.5,
n_unconditioned=1,
verbose=False
)
hamming_network.train(input_data, epochs=1)
np.testing.assert_array_almost_equal(
hamming_network.input_layer.weight,
np.array([
[0.7071, 0.7071, -1],
[-0.5704, 0.8439, 0.1368]
]),
decimal=4
)
def test_train_different_inputs(self):
self.assertInvalidVectorTrain(
algorithms.Instar(step=1, verbose=False,
**self.default_properties),
np.array([[0, 1, -1, -1]]),
is_feature1d=False,
)
def test_train_different_inputs(self):
self.assertInvalidVectorTrain(
algorithms.Instar(layers.StepLayer(4) > layers.OutputLayer(1),
n_unconditioned=1,
step=1,
verbose=False),
np.array([[0, 1, -1, -1]]),
row1d=True,
)
def test_predict_different_inputs(self):
inet = algorithms.Instar(step=1,
verbose=False,
**self.default_properties)
inet.train(X, epochs=10)
self.assertInvalidVectorPred(inet,
np.array([0, 1, -1, -1]),
1,
is_feature1d=False)
def test_predict_different_inputs(self):
inet = algorithms.Instar(
self.conn,
n_unconditioned=1,
step=1,
verbose=False
)
inet.train(input_data, epochs=10)
self.assertInvalidVectorPred(inet, np.array([0, 1, -1, -1]), 1,
row1d=True)
def test_learning_process(self):
inet = algorithms.Instar(step=1,
verbose=False,
**self.default_properties)
inet.train(X, epochs=10)
test_input = np.array([[0, 1, -1, -1]])
self.assertEqual(inet.predict(test_input), 1)
np.testing.assert_array_equal(inet.weight,
np.array([[3, 1, -1, -1]]).T)
def test_learning_process(self):
inet = algorithms.Instar(self.conn,
n_unconditioned=1,
step=1,
verbose=False)
inet.train(input_data, epochs=10)
test_input = np.array([[0, 1, -1, -1]])
self.assertEqual(inet.predict(test_input), 1)
np.testing.assert_array_equal(inet.input_layer.weight,
np.array([[3, 1, -1, -1]]).T)
def test_multiple_outputs(self):
X = np.array([
[-0.1961, 0.9806],
])
innet = algorithms.Instar(n_inputs=2,
n_outputs=3,
n_unconditioned=1,
weight=np.array([
[0.7071, 0.7071, -1],
[-0.7071, 0.7071, 0],
]),
step=0.5,
verbose=False)
innet.train(X, epochs=1)
np.testing.assert_array_almost_equal(innet.weight,
np.array(
[[0.7071, 0.7071, -1],
[-0.5704, 0.8439, 0.1368]]),
decimal=4)
import numpy as np
from neupy import layers, algorithms
input_data = np.array([
[-0.1961, 0.9806],
])
input_size, output_size = (2, 3)
input_layer = layers.StepLayer(input_size,
weight=np.array([
[0.7071, -0.7071],
[0.7071, 0.7071],
[-1, 0],
]).T,
function_coef={
'lower_value': 0,
'upper_value': 1
})
output_layer = layers.CompetitiveOutputLayer(output_size)
hamming_network = algorithms.Instar(input_layer > output_layer,
use_bias=False,
step=0.5,
n_unconditioned=0)
with hamming_network as hn:
hn.train(input_data, epochs=1)
print(hn.input_layer.weight)
