12162489906

Committed 04 Dec 2024 03:04PM UTC coverage: 93.934% (-0.2%) from 94.155%

Build # 12162489906

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #6 from tonegas/release/0.15.0

Release/0.15.0

Run Details

37 of 42 new or added lines in 8 files covered. (88.1%)

59 existing lines in 7 files now uncovered.

8625 of 9182 relevant lines covered (93.93%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.15

/tests/test_train.py

import unittest, os, sys
import numpy as np

from nnodely import *
from nnodely.relation import NeuObj
from nnodely import relation
relation.CHECK_NAMES = False

from nnodely.logger import logging, nnLogger
log = nnLogger(__name__, logging.CRITICAL)
log.setAllLevel(logging.CRITICAL)

sys.path.append(os.getcwd())

# 4 Tests
# This file tests the value of the training parameters

data_folder = os.path.join(os.path.dirname(__file__), 'data/')

class ModelyTrainingTest(unittest.TestCase):
    def TestAlmostEqual(self, data1, data2, precision=4):
        assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}'
        if type(data1) == type(data2) == list:
            self.assertEqual(len(data1), len(data2))
            for pred, label in zip(data1, data2):
                self.TestAlmostEqual(pred, label, precision=precision)
        else:
            self.assertAlmostEqual(data1, data2, places=precision)

    def test_training_values_fir(self):
        input1 = Input('in1')
        target = Input('out1')
        a = Parameter('a', values=[[1]])
        output1 = Output('out', Fir(parameter=a)(input1.last()))

        test = Modely(visualizer=None,seed=42)
        test.addModel('model', output1)
        test.addMinimize('error', target.last(), output1)
        test.neuralizeModel()

        dataset = {'in1': [1], 'out1': [2]}
        test.loadData(name='dataset', source=dataset)

        self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[3.0]],test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2)
        self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())

    def test_training_values_linear(self):
        NeuObj.reset_count()
        input1 = Input('in1')
        target = Input('out1')
        W = Parameter('W', values=[[[1]]])
        b = Parameter('b', values=[[1]])
        output1 = Output('out', Linear(W=W,b=b)(input1.last()))

        test = Modely(visualizer=None, seed=42)
        test.addModel('model', output1)
        test.addMinimize('error', target.last(), output1)
        test.neuralizeModel()

        dataset = {'in1': [1], 'out1': [3]}
        test.loadData(name='dataset', source=dataset)

        self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[-3.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[-3.0]], test.model.all_parameters['b'].data.numpy().tolist())

    def test_training_clear_model(self):
        NeuObj.reset_count()
        input1 = Input('in1')
        target = Input('int1')
        a = Parameter('a', values=[[1]])
        fir_out = Fir(parameter=a)(input1.last())
        output1 = Output('out1', fir_out)

        W = Parameter('W', values=[[[1]]])
        b = Parameter('b', values=[[1]])
        output2 = Output('out2', Linear(W=W,b=b)(fir_out))

        test = Modely(visualizer=None, seed=42)
        test.addModel('model', [output1,output2])
        test.addMinimize('error', target.last(), output2)
        test.neuralizeModel()
        self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]}))

        dataset = {'in1': [1], 'int1': [3]}
        test.loadData(name='dataset', source=dataset)

        self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[1.0]], test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[3.0]], test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[-51.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[-15.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[-51.0]], test.model.all_parameters['a'].data.numpy().tolist())

        test.neuralizeModel(clear_model=True)
        self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[1.0]], test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[3.0]], test.model.all_parameters['a'].data.numpy().tolist())
        test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)
        self.assertListEqual([[[-51.0]]],test.model.all_parameters['W'].data.numpy().tolist())
        self.assertListEqual([[-15.0]], test.model.all_parameters['b'].data.numpy().tolist())
        self.assertListEqual([[-51.0]], test.model.all_parameters['a'].data.numpy().tolist())

    def test_multimodel_with_loss_gain_and_lr_gain(self):
        ## Model1
        input1 = Input('in1')
        a1 = Parameter('a1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])
        output11 = Output('out11', Fir(parameter=a1)(input1.tw(0.05)))
        a2 = Parameter('a2', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]])
        output12 = Output('out12', Fir(parameter=a2)(input1.tw(0.05)))
        a3 = Parameter('a3', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]])
        output13 = Output('out13', Fir(parameter=a3)(input1.tw(0.05)))

        test = Modely(visualizer=None, seed=42)
        test.addModel('model1', [output11, output12, output13])
        test.addMinimize('error11', input1.next(), output11)
        test.addMinimize('error12', input1.next(), output12)
        test.addMinimize('error13', input1.next(), output13)

        ## Model2
        input2 = Input('in2')
        b1 = Parameter('b1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])
        output21 = Output('out21', Fir(parameter=b1)(input2.tw(0.05)))
        b2 = Parameter('b2', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])
        output22 = Output('out22', Fir(parameter=b2)(input2.tw(0.05)))
        b3 = Parameter('b3', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])
        output23 = Output('out23', Fir(parameter=b3)(input2.tw(0.05)))

        test.addModel('model2', [output21, output22, output23])
        test.addMinimize('error21', input2.next(), output21)
        test.addMinimize('error22', input2.next(), output22)
        test.addMinimize('error23', input2.next(), output23)
        test.neuralizeModel(0.01)

        data_in1 = [1, 1, 1, 1, 1, 2]
        data_in2 = [1, 1, 1, 1, 1, 2]
        dataset = {'in1': data_in1, 'in2': data_in2}

        test.loadData(name='dataset', source=dataset)

        ## Train only model1
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])
        test.trainModel(optimizer='SGD', models='model1', splits=[100,0,0], lr=1, num_of_epochs=1)
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])

        ## Train only model2
        test.neuralizeModel(0.01, clear_model=True)
        test.trainModel(optimizer='SGD', models='model2', splits=[100,0,0], lr=1, num_of_epochs=1)
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])

        ## Train both models
        test.neuralizeModel(0.01, clear_model=True)
        test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1)
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])

        ## Train both models but set the gain of a to zero and the gain of b to double
        test.neuralizeModel(0.01, clear_model=True)
        test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, lr_param={'a1':0, 'b1':2})
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-11],[-11],[-11],[-11],[-11]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])

        ## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double
        test.neuralizeModel(0.01, clear_model=True)
        test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':0})
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])

        ## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double
        test.neuralizeModel(0.01, clear_model=True)
        test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':-1,'error22':2})
        self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[7],[7],[7],[7],[7]])
        self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-11],[-11],[-11],[-11],[-11]])
        self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])
        self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])

if __name__ == '__main__':
    unittest.main()

1	import unittest, os, sys	1✔
2	import numpy as np	1✔
3
4	from nnodely import *	1✔
5	from nnodely.relation import NeuObj	1✔
6	from nnodely import relation	1✔
7	relation.CHECK_NAMES = False	1✔
8
9	from nnodely.logger import logging, nnLogger	1✔
10	log = nnLogger(__name__, logging.CRITICAL)	1✔
11	log.setAllLevel(logging.CRITICAL)	1✔
12
13	sys.path.append(os.getcwd())	1✔
14
15	# 4 Tests
16	# This file tests the value of the training parameters
17
18	data_folder = os.path.join(os.path.dirname(__file__), 'data/')	1✔
19
20	class ModelyTrainingTest(unittest.TestCase):	1✔
21	def TestAlmostEqual(self, data1, data2, precision=4):	1✔
22	assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}'	×
23	if type(data1) == type(data2) == list:	×
NEW 24	self.assertEqual(len(data1), len(data2))	×
25	for pred, label in zip(data1, data2):	×
26	self.TestAlmostEqual(pred, label, precision=precision)	×
27	else:
28	self.assertAlmostEqual(data1, data2, places=precision)	×
29
30	def test_training_values_fir(self):	1✔
31	input1 = Input('in1')	1✔
32	target = Input('out1')	1✔
33	a = Parameter('a', values=[[1]])	1✔
34	output1 = Output('out', Fir(parameter=a)(input1.last()))	1✔
35
36	test = Modely(visualizer=None,seed=42)	1✔
37	test.addModel('model', output1)	1✔
38	test.addMinimize('error', target.last(), output1)	1✔
39	test.neuralizeModel()	1✔
40
41	dataset = {'in1': [1], 'out1': [2]}	1✔
42	test.loadData(name='dataset', source=dataset)	1✔
43
44	self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())	1✔
45	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
46	self.assertListEqual([[3.0]],test.model.all_parameters['a'].data.numpy().tolist())	1✔
47	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
48	self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())	1✔
49	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2)	1✔
50	self.assertListEqual([[1.0]],test.model.all_parameters['a'].data.numpy().tolist())	1✔
51
52	def test_training_values_linear(self):	1✔
53	NeuObj.reset_count()	1✔
54	input1 = Input('in1')	1✔
55	target = Input('out1')	1✔
56	W = Parameter('W', values=[[[1]]])	1✔
57	b = Parameter('b', values=[[1]])	1✔
58	output1 = Output('out', Linear(W=W,b=b)(input1.last()))	1✔
59
60	test = Modely(visualizer=None, seed=42)	1✔
61	test.addModel('model', output1)	1✔
62	test.addMinimize('error', target.last(), output1)	1✔
63	test.neuralizeModel()	1✔
64
65	dataset = {'in1': [1], 'out1': [3]}	1✔
66	test.loadData(name='dataset', source=dataset)	1✔
67
68	self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
69	self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
70	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
71	self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())	1✔
72	self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
73	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
74	self.assertListEqual([[[-3.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
75	self.assertListEqual([[-3.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
76
77	def test_training_clear_model(self):	1✔
78	NeuObj.reset_count()	1✔
79	input1 = Input('in1')	1✔
80	target = Input('int1')	1✔
81	a = Parameter('a', values=[[1]])	1✔
82	fir_out = Fir(parameter=a)(input1.last())	1✔
83	output1 = Output('out1', fir_out)	1✔
84
85	W = Parameter('W', values=[[[1]]])	1✔
86	b = Parameter('b', values=[[1]])	1✔
87	output2 = Output('out2', Linear(W=W,b=b)(fir_out))	1✔
88
89	test = Modely(visualizer=None, seed=42)	1✔
90	test.addModel('model', [output1,output2])	1✔
91	test.addMinimize('error', target.last(), output2)	1✔
92	test.neuralizeModel()	1✔
93	self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]}))	1✔
94
95	dataset = {'in1': [1], 'int1': [3]}	1✔
96	test.loadData(name='dataset', source=dataset)	1✔
97
98	self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
99	self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
100	self.assertListEqual([[1.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
101	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
102	self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())	1✔
103	self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
104	self.assertListEqual([[3.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
105	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
106	self.assertListEqual([[[-51.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
107	self.assertListEqual([[-15.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
108	self.assertListEqual([[-51.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
109
110	test.neuralizeModel(clear_model=True)	1✔
111	self.assertListEqual([[[1.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
112	self.assertListEqual([[1.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
113	self.assertListEqual([[1.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
114	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
115	self.assertListEqual([[[3.0]]], test.model.all_parameters['W'].data.numpy().tolist())	1✔
116	self.assertListEqual([[3.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
117	self.assertListEqual([[3.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
118	test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1)	1✔
119	self.assertListEqual([[[-51.0]]],test.model.all_parameters['W'].data.numpy().tolist())	1✔
120	self.assertListEqual([[-15.0]], test.model.all_parameters['b'].data.numpy().tolist())	1✔
121	self.assertListEqual([[-51.0]], test.model.all_parameters['a'].data.numpy().tolist())	1✔
122
123	def test_multimodel_with_loss_gain_and_lr_gain(self):	1✔
124	## Model1
125	input1 = Input('in1')	1✔
126	a1 = Parameter('a1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])	1✔
127	output11 = Output('out11', Fir(parameter=a1)(input1.tw(0.05)))	1✔
128	a2 = Parameter('a2', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]])	1✔
129	output12 = Output('out12', Fir(parameter=a2)(input1.tw(0.05)))	1✔
130	a3 = Parameter('a3', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]])	1✔
131	output13 = Output('out13', Fir(parameter=a3)(input1.tw(0.05)))	1✔
132
133	test = Modely(visualizer=None, seed=42)	1✔
134	test.addModel('model1', [output11, output12, output13])	1✔
135	test.addMinimize('error11', input1.next(), output11)	1✔
136	test.addMinimize('error12', input1.next(), output12)	1✔
137	test.addMinimize('error13', input1.next(), output13)	1✔
138
139	## Model2
140	input2 = Input('in2')	1✔
141	b1 = Parameter('b1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])	1✔
142	output21 = Output('out21', Fir(parameter=b1)(input2.tw(0.05)))	1✔
143	b2 = Parameter('b2', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])	1✔
144	output22 = Output('out22', Fir(parameter=b2)(input2.tw(0.05)))	1✔
145	b3 = Parameter('b3', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]])	1✔
146	output23 = Output('out23', Fir(parameter=b3)(input2.tw(0.05)))	1✔
147
148	test.addModel('model2', [output21, output22, output23])	1✔
149	test.addMinimize('error21', input2.next(), output21)	1✔
150	test.addMinimize('error22', input2.next(), output22)	1✔
151	test.addMinimize('error23', input2.next(), output23)	1✔
152	test.neuralizeModel(0.01)	1✔
153
154	data_in1 = [1, 1, 1, 1, 1, 2]	1✔
155	data_in2 = [1, 1, 1, 1, 1, 2]	1✔
156	dataset = {'in1': data_in1, 'in2': data_in2}	1✔
157
158	test.loadData(name='dataset', source=dataset)	1✔
159
160	## Train only model1
161	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
162	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
163	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
164	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
165	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
166	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[1], [1], [1], [1], [1]])	1✔
167	test.trainModel(optimizer='SGD', models='model1', splits=[100,0,0], lr=1, num_of_epochs=1)	1✔
168	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
169	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
170	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
171	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
172	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
173	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
174
175	## Train only model2
176	test.neuralizeModel(0.01, clear_model=True)	1✔
177	test.trainModel(optimizer='SGD', models='model2', splits=[100,0,0], lr=1, num_of_epochs=1)	1✔
178	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
179	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
180	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
181	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
182	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
183	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
184
185	## Train both models
186	test.neuralizeModel(0.01, clear_model=True)	1✔
187	test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1)	1✔
188	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
189	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
190	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
191	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
192	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
193	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
194
195	## Train both models but set the gain of a to zero and the gain of b to double
196	test.neuralizeModel(0.01, clear_model=True)	1✔
197	test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, lr_param={'a1':0, 'b1':2})	1✔
198	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
199	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-11],[-11],[-11],[-11],[-11]])	1✔
200	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
201	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
202	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
203	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
204
205	## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double
206	test.neuralizeModel(0.01, clear_model=True)	1✔
207	test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':0})	1✔
208	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[1],[1],[1],[1],[1]])	1✔
209	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
210	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
211	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
212	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
213	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
214
215	## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double
216	test.neuralizeModel(0.01, clear_model=True)	1✔
217	test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':-1,'error22':2})	1✔
218	self.assertListEqual(test.model.all_parameters['a1'].data.numpy().tolist(), [[7],[7],[7],[7],[7]])	1✔
219	self.assertListEqual(test.model.all_parameters['b1'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
220	self.assertListEqual(test.model.all_parameters['a2'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
221	self.assertListEqual(test.model.all_parameters['b2'].data.numpy().tolist(), [[-11],[-11],[-11],[-11],[-11]])	1✔
222	self.assertListEqual(test.model.all_parameters['a3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
223	self.assertListEqual(test.model.all_parameters['b3'].data.numpy().tolist(), [[-5],[-5],[-5],[-5],[-5]])	1✔
224
225	if __name__ == '__main__':	1✔
226	unittest.main()	×

tonegas / nnodely / 12162489906

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous