def test_addTwoFunctions(self):
function_generator = FunctionGenerator()
function_generator.addFunction([10, 4, 3])
function_generator.addFunction([-5, 4, 3])
expected_output = '10x^2 + 4x + 3\n' \
'-5x^2 + 4x + 3\n'
self.assertEqual(expected_output, function_generator.to_string())
def test_generateOneSample(self):
function_generator = FunctionGenerator()
a, b, c = 10, 4, 3
function_generator.addFunction([a, b, c])
testing_set = function_generator.generate()
first_function_index = 0
self.assertEqual([-1], testing_set.X.T[first_function_index])
self.assertEqual([0.5], testing_set.Y.T[first_function_index])
def __generate_functions(self, args):
self.__add_function_to_generator(args.f_1)
self.__add_function_to_generator(args.f_2)
self.__add_function_to_generator(args.f_3)
training_function_generator = FunctionGenerator()
for function in self.__training_functions:
training_function_generator.addFunction(function)
required_samples = args.SampleNumber
training_set = training_function_generator.generate(required_samples)
input_number = output_number = self.__input_number
return input_number, output_number, required_samples, training_set
def test_generate100ContinuousSamples(self):
function_generator = FunctionGenerator()
# f(x) = x
function_generator.addFunction([1, 0])
sample_number = 100
testing_set = function_generator.generate(sample_number)
first_function_idx = 0
for sample_idx in range(sample_number):
self.assertAlmostEqual(
sample_idx / sample_number,
testing_set.Y.T[first_function_idx][sample_idx],
delta=0.011)
def test_generateTripleSampleTripleFunction(self):
function_generator = FunctionGenerator()
function_number = 3
base_factor = 10
for x in range(function_number):
# f(x) = 2x^1 + 10
function_generator.addFunction([2, base_factor])
sample_number = 3
testing_set = function_generator.generate(sample_number)
for function_idx in range(function_number):
self.assertAlmostEqual(0., testing_set.Y.T[function_idx][0])
self.assertAlmostEqual(.5, testing_set.Y.T[function_idx][1])
self.assertAlmostEqual(1., testing_set.Y.T[function_idx][2])
def test_conductTestM7(self):
print('Conduct M7')
input_number = output_number = 3
parameter_m = 7
training_functions = [
[-3, 0, -7, 21, 0, -8, 0.4], # -3x6 – 7x4 + 21x3 – 8x + 0.4
[1, 0, 0, -10, 0, 0, 0.2], # x^6 -x10x^2 + 0.2
[-1, 1, 0, 0, 4, 0, -10], # -2x^6 + x^5 + 4x^2 - 10
]
self.assertEqual(
parameter_m, len(training_functions[0]),
'This tests requires {}-parameter functions'.format(parameter_m))
training_function_generator = FunctionGenerator()
for function in training_functions:
training_function_generator.addFunction(function)
print('Used functions: \n', training_function_generator.to_string())
required_samples = 130
training_set = training_function_generator.generate(required_samples)
ratio = 5
fitting_set_x, fitting_set_y, testing_set_x, testing_set_y = self.__mlp_utils.split_data_set(
input_number, output_number, ratio, required_samples, training_set)
self.__train_and_plot(fitting_set_x, fitting_set_y, testing_set_x,
testing_set_y, parameter_m)
def test_conductTestM5(self):
print('Conduct M5')
input_number = output_number = 3
parameter_m = 5
training_functions = [
[-7, 21, 0, -8, 0.1], # -7x4 + 21x3 – 8x + 24
[-20, 0, 0, 0, 2], # -20x^4 + 2
[3, 0, -4, 0, -9], # 3x^4 - 4x^2 - 9
]
self.assertEqual(
parameter_m, len(training_functions[0]),
'This tests requires {}-parameter functions'.format(parameter_m))
training_function_generator = FunctionGenerator()
for function in training_functions:
training_function_generator.addFunction(function)
print('Used functions: \n', training_function_generator.to_string())
required_samples = 130
training_set = training_function_generator.generate(required_samples)
ratio = 5
fitting_set_x, fitting_set_y, testing_set_x, testing_set_y = self.__mlp_utils.split_data_set(
input_number, output_number, ratio, required_samples, training_set)
self.__train_and_plot(fitting_set_x, fitting_set_y, testing_set_x,
testing_set_y, parameter_m)
def test_conductTestM3(self):
print('Conduct M3')
input_number = output_number = 3
parameter_m = 3
training_functions = [
[1, 1, 0], # x^2 + x
[1, -1, 0], # x^2 - x
[-2, 2, 0] # -2x^2 + 2x
]
self.assertEqual(
parameter_m, len(training_functions[0]),
'This tests requires {}-parameter functions'.format(parameter_m))
training_function_generator = FunctionGenerator()
for function in training_functions:
training_function_generator.addFunction(function)
print('Used functions: \n', training_function_generator.to_string())
required_samples = 130
training_set = training_function_generator.generate(required_samples)
ratio = 5
fitting_set_x, fitting_set_y, testing_set_x, testing_set_y = self.__mlp_utils.split_data_set(
input_number, output_number, ratio, required_samples, training_set)
self.__train_and_plot(fitting_set_x, fitting_set_y, testing_set_x,
testing_set_y, parameter_m)
def test_generateOneSampleDoubleFunction(self):
function_generator = FunctionGenerator()
a, b, c = 10., 4., 3.
function_generator.addFunction([a, b, c])
function_generator.addFunction([a, b, c + 1.])
testing_set = function_generator.generate()
first_sample_indxe = 0
first_function_index = 0
self.assertAlmostEqual(
-1., testing_set.X.T[first_function_index][first_sample_indxe])
self.assertAlmostEqual(
0., testing_set.Y.T[first_function_index][first_sample_indxe])
second_function_index = 1
self.assertAlmostEqual(
-1., testing_set.X.T[second_function_index][first_sample_indxe])
self.assertAlmostEqual(
1., testing_set.Y.T[second_function_index][first_sample_indxe])
def test_addOneFunction(self):
function_generator = FunctionGenerator()
function_generator.addFunction([10, 4, 3])
expected_output = "10x^2 + 4x + 3\n"
self.assertEqual(expected_output, function_generator.to_string())