Improve tests (#29)

* Improve tests

* Add _POSIX_C_SOURCE back

scripts/test/gen/nn_act_func.py

@@ -0,0 +1,34 @@
+# This script generates test cases for nn_act_func_softmax function.
+
+import numpy as np
+
+# Returns the softmax activation function result.
+def nn_act_func_softmax(x):
+ exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
+ return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
+
+# Generates a test case.
+def generate_test_case(input):
+ input_c = ", ".join(map(str, input.flatten()))
+ expected_value = nn_act_func_softmax(input)
+ expected_value_c = ", ".join(map(str, expected_value.flatten()))
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_TENSOR, nn_act_func_softmax),
+ .input = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{input_c}}}, NULL),
+ .expected_value = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{expected_value_c}}}, NULL),
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [
+ np.array([0.8, 0.2, 0.1]),
+ np.array([-0.6, 0.0, 0.6]),
+ np.array([0.3, -0.3, 0.0])
+]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_identity.py

@@ -0,0 +1,22 @@
+# This script generates test cases for nn_act_func_identity function.
+
+import numpy as np
+
+# Generates a test case.
+def generate_test_case(input):
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_SCALAR, nn_act_func_identity),
+ .input = {input},
+ .expected_value = {input},
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [-1.0, 0.0, 1.0]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_relu.py

@@ -0,0 +1,27 @@
+# This script generates test cases for nn_act_func_relu function.
+
+import numpy as np
+
+# Returns the ReLU activation function result.
+def nn_act_func_relu(x):
+ return np.maximum(0, x)
+
+# Generates a test case.
+def generate_test_case(input):
+ expected_value = nn_act_func_relu(input)
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_SCALAR, nn_act_func_relu),
+ .input = {input},
+ .expected_value = {expected_value},
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [-2.0, -1.0, 0.0, 1.0, 2.0]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_scalar_batch.py

@@ -0,0 +1,33 @@
+# This script generates test cases for nn_act_func_softmax function.
+
+import numpy as np
+
+# Returns the ReLU activation function result.
+def nn_act_func_relu(x):
+ return np.maximum(0, x)
+
+# Generates a test case.
+def generate_test_case(input):
+ input_c = ", ".join(map(str, input.flatten()))
+ expected_value = nn_act_func_relu(input)
+ expected_value_c = ", ".join(map(str, expected_value.flatten()))
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_TENSOR, nn_act_func_relu),
+ .input = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{input_c}}}, NULL),
+ .expected_value = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{expected_value_c}}}, NULL),
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [
+ np.array([0.8, 0.2, -0.1, 0.0]),
+ np.array([-0.6, 0.0, 0.6, -1.0]),
+ np.array([0.3, -0.3, 1.0, 0.0])
+]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_sigmoid.py

@@ -0,0 +1,27 @@
+# This script generates test cases for nn_act_func_sigmoid function.
+
+import numpy as np
+
+# Returns the sigmoid activation function result.
+def nn_act_func_sigmoid(x):
+ return 1 / (1 + np.exp(-x))
+
+# Generates test cases.
+def generate_test_case(input):
+ expected_value = nn_act_func_sigmoid(input)
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_SCALAR, nn_act_func_sigmoid),
+ .input = {input},
+ .expected_value = {expected_value},
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [-2.0, -1.0, 0.0, 1.0, 2.0]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_softmax.py

@@ -0,0 +1,34 @@
+# This script generates test cases for nn_act_func_softmax function.
+
+import numpy as np
+
+# Returns the softmax activation function result.
+def nn_act_func_softmax(x):
+ exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
+ return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
+
+# Generates a test case.
+def generate_test_case(input):
+ input_c = ", ".join(map(str, input.flatten()))
+ expected_value = nn_act_func_softmax(input)
+ expected_value_c = ", ".join(map(str, expected_value.flatten()))
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_TENSOR, nn_act_func_softmax),
+ .input = nn_tensor_init_NNTensor(1, (const size_t[]){{{len(input)}}}, false, (const NNTensorUnit[]){{{input_c}}}, NULL),
+ .expected_value = nn_tensor_init_NNTensor(1, (const size_t[]){{{len(input)}}}, false, (const NNTensorUnit[]){{{expected_value_c}}}, NULL),
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [
+ np.array([1.0, 2.0, 3.0]),
+ np.array([-1.0, 0.0, 1.0]),
+ np.array([0.5, -0.5, 0.0])
+]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/gen/nn_act_func_tensor_batch.py

@@ -0,0 +1,34 @@
+# This script generates test cases for nn_act_func_softmax function.
+
+import numpy as np
+
+# Returns the softmax activation function result.
+def nn_act_func_softmax(x):
+ exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
+ return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
+
+# Generates a test case.
+def generate_test_case(input):
+ input_c = ", ".join(map(str, input.flatten()))
+ expected_value = nn_act_func_softmax(input)
+ expected_value_c = ", ".join(map(str, expected_value.flatten()))
+ return f"""
+ {{
+ .act_func = nn_act_func_init(NN_ACT_FUNC_TENSOR, nn_act_func_softmax),
+ .input = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{input_c}}}, NULL),
+ .expected_value = nn_tensor_init_NNTensor(2, (const size_t[]){{1, {len(input)}}}, false, (const NNTensorUnit[]){{{expected_value_c}}}, NULL),
+ .expected_tolerance = default_expected_tolerance,
+ }}"""
+
+# Generate test cases
+np.random.seed(2024)
+test_cases = []
+inputs = [
+ np.array([-0.1, 0.2, 0.8, 0.0]),
+ np.array([1.0, 0.5, -0.4, -1.0]),
+ np.array([0.9, -0.3, 0.1, 0.0])
+]
+for input in inputs:
+ test_cases.append(generate_test_case(input))
+
+print(f"TestCase test_cases[] = {{{', '.join(test_cases)},\n}};")

scripts/test/layer_gen_tc.py → scripts/test/gen/nn_layer.py

@@ -1,4 +1,4 @@
-# This script generates test cases for NNLayer.
+# This script generates test cases for NNLayer struct.
 
 import numpy as np
 

scripts/test/layer_multi_gen_tc.py → scripts/test/gen/nn_layer_multi.py

@@ -1,4 +1,4 @@
-# This script generates test cases for NNLayer.
+# This script generates test cases for NNLayer struct.
 
 import numpy as np
 

src/nn_activation.c

@@ -6,8 +6,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-// TODO: Add tests
-
 NNActFunc nn_act_func_init(NNActFuncType type, void *func) {
  NN_DEBUG_PRINT(5, "function %s called with type=%d\n", __func__, type);
 
@@ -138,11 +136,9 @@ bool nn_act_func_tensor_batch(const NNActFuncTensor act_func, const NNTensor *in
  size_t sizes[1] = {sample_size};
  NNTensor input_slice;
  NNTensor output_slice;
-
  for (size_t i = 0; i < batch_size; i++) {
  nn_tensor_slice(input, i * sample_size, sizes, &input_slice);
  nn_tensor_slice(output, i * sample_size, sizes, &output_slice);
-
  if (!act_func(&input_slice, &output_slice, error)) {
  return false;
  }

src/nn_layer.c

@@ -172,12 +172,15 @@ bool nn_layer_forward(const NNLayer *layer, const NNTensor *inputs, NNTensor *ou
  }
  // TODO: Should we overwrite the weights tensor so that we don't have to allocate a new tensor every time?
  if (!nn_mat_transpose(layer->weights, weights, error)) {
+ nn_tensor_destroy_NNTensor(weights);
  return false;
  }
  // Perform matrix multiplication
  if (!layer->mat_mul_func(inputs, weights, outputs, error)) {
+ nn_tensor_destroy_NNTensor(weights);
  return false;
  }
+ nn_tensor_destroy_NNTensor(weights);
  } else {
  // Perform matrix multiplication
  if (!layer->mat_mul_func(inputs, layer->weights, outputs, error)) {

tests/arch/arm/cmsis-dsp/dot_prod_perf/main.c

@@ -21,13 +21,13 @@ int main(int argc, char *argv[]) {
  struct timespec start, end;
  long long total_time = 0;
  const int batch_size = 1024;
- const int n_vectors = 4096;
+ const int vector_size = 4096;
  NNTensor *vec_a[batch_size];
  NNTensor *vec_b[batch_size];
  for (int i = 0; i < batch_size; i++) {
- vec_a[i] = nn_tensor_init_NNTensor(1, (const size_t[]){4096}, false, NULL, NULL);
- vec_b[i] = nn_tensor_init_NNTensor(1, (const size_t[]){4096}, false, NULL, NULL);
- for (int j = 0; j < n_vectors; ++j) {
+ vec_a[i] = nn_tensor_init_NNTensor(1, (const size_t[]){vector_size}, false, NULL, NULL);
+ vec_b[i] = nn_tensor_init_NNTensor(1, (const size_t[]){vector_size}, false, NULL, NULL);
+ for (int j = 0; j < vector_size; ++j) {
  vec_a[i]->data[j] = (NNTensorUnit)rand() / (NNTensorUnit)RAND_MAX;
  vec_b[i]->data[j] = (NNTensorUnit)rand() / (NNTensorUnit)RAND_MAX;
  }

tests/arch/arm/neon/dot_prod_perf/main.c

@@ -21,13 +21,13 @@ int main(int argc, char *argv[]) {
  struct timespec start, end;
  long long total_time = 0;
  const int batch_size = 1024;
- const int n_vectors = 4096;
+ const int vector_size = 4096;
  NNTensor *vec_a[batch_size];
  NNTensor *vec_b[batch_size];
  for (int i = 0; i < batch_size; i++) {
- vec_a[i] = nn_tensor_init_NNTensor(1, (const size_t[]){4096}, false, NULL, NULL);
- vec_b[i] = nn_tensor_init_NNTensor(1, (const size_t[]){4096}, false, NULL, NULL);
- for (int j = 0; j < n_vectors; ++j) {
+ vec_a[i] = nn_tensor_init_NNTensor(1, (const size_t[]){vector_size}, false, NULL, NULL);
+ vec_b[i] = nn_tensor_init_NNTensor(1, (const size_t[]){vector_size}, false, NULL, NULL);
+ for (int j = 0; j < vector_size; ++j) {
  vec_a[i]->data[j] = (NNTensorUnit)rand() / (NNTensorUnit)RAND_MAX;
  vec_b[i]->data[j] = (NNTensorUnit)rand() / (NNTensorUnit)RAND_MAX;
  }

tests/arch/generic/activation/activation.h

@@ -0,0 +1,8 @@
+void test_nn_act_func_init();
+void test_nn_act_func();
+void test_nn_act_func_identity();
+void test_nn_act_func_sigmoid();
+void test_nn_act_func_relu();
+void test_nn_act_func_softmax();
+void test_nn_act_func_scalar_batch();
+void test_nn_act_func_tensor_batch();

tests/arch/generic/activation/include.txt

@@ -0,0 +1,15 @@
+tests/arch/generic/activation/nn_act_func_init.c
+tests/arch/generic/activation/nn_act_func.c
+tests/arch/generic/activation/nn_act_func_identity.c
+tests/arch/generic/activation/nn_act_func_sigmoid.c
+tests/arch/generic/activation/nn_act_func_relu.c
+tests/arch/generic/activation/nn_act_func_softmax.c
+tests/arch/generic/activation/nn_act_func_scalar_batch.c
+tests/arch/generic/activation/nn_act_func_tensor_batch.c
+src/nn_activation.c
+src/nn_app.c
+src/nn_argmax.c
+src/nn_config.c
+src/nn_error.c
+src/nn_test.c
+src/nn_tensor.c

tests/arch/generic/activation/main.c

@@ -0,0 +1,18 @@
+#include "./activation.h"
+#include "nn_app.h"
+
+int main(int argc, char *argv[]) {
+ nn_init_app(argc, argv);
+ // nn_set_debug_level(5); // for debugging
+
+ test_nn_act_func_init();
+ test_nn_act_func();
+ test_nn_act_func_identity();
+ test_nn_act_func_sigmoid();
+ test_nn_act_func_relu();
+ test_nn_act_func_softmax();
+ test_nn_act_func_scalar_batch();
+ test_nn_act_func_tensor_batch();
+
+ return 0;
+}