Bug Summary

File:nnc/ccv_cnnp_model_addons.c
Warning:line 1132, column 2
The left operand of '%' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ccv_cnnp_model_addons.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +sse2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -fcoverage-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -resource-dir /usr/local/lib/clang/19 -I ../ -I /usr/local/cuda/include -D HAVE_CBLAS -D HAVE_LIBPNG -D HAVE_LIBJPEG -D HAVE_FFTW3 -D HAVE_PTHREAD -D HAVE_LIBLINEAR -D HAVE_TESSERACT -D HAVE_AVCODEC -D HAVE_AVFORMAT -D HAVE_AVUTIL -D HAVE_SWSCALE -D HAVE_SSE2 -D HAVE_GSL -D HAVE_CUDA -D HAVE_CUDNN -D HAVE_NCCL -D USE_SYSTEM_CUB -I /usr/local/include -internal-isystem /usr/local/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/liu/actions-runner/_work/ccv/ccv/_analyze/2025-03-24-220155-150127-1 -x c ccv_cnnp_model_addons.c
1#include "ccv_nnc.h"
2#include "ccv_nnc_easy.h"
3#include "ccv_nnc_internal.h"
4#include "ccv_internal.h"
5#include "_ccv_cnnp_model.h"
6
7// MARK - Add-on Functions
8
9static int _ccv_cnnp_model_clip_grad_norm_reduce_norm2(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
10{
11 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
12 ccv_nnc_tensor_t* const old_norm2 = outputs[1 + device_id * 2];
13 ccv_nnc_tensor_t* const norm2 = outputs[1 + device_id * 2 + 1];
14 const int tensor_count = ccv_nnc_tensor_count(inputs[0]->info);
15 if (tensor_count == 1)
16 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(inputs[0], inputs[0])(ccv_nnc_tensor_t* []){inputs[0], inputs[0]}, (1 +1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
17 else {
18 ccv_nnc_cmd_exec(CMD_REDUCE_NORM2_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_NORM2_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0), hint, flags, TENSOR_LIST(inputs[0])(ccv_nnc_tensor_t* []){inputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
19 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(norm2, norm2)(ccv_nnc_tensor_t* []){norm2, norm2}, (1 +1 +1 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
20 }
21 ccv_nnc_cmd_exec(CMD_ADD_FORWARD(1, 1)ccv_nnc_cmd(CCV_NNC_ADD_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1, 1}}}, 0), hint, flags, TENSOR_LIST(old_norm2, norm2)(ccv_nnc_tensor_t* []){old_norm2, norm2}, (1 +1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(old_norm2)(ccv_nnc_tensor_t* []){old_norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
22 return CCV_NNC_EXEC_SUCCESS;
23}
24
25static ccv_nnc_cmd_vtab_t clip_grad_norm_reduce_norm2_vtab = {
26 .exec = _ccv_cnnp_model_clip_grad_norm_reduce_norm2
27};
28
29static int _ccv_cnnp_model_clip_grad_norm_scatter_norm2(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
30{
31 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
32 ccv_nnc_tensor_t* const norm2 = inputs[1 + device_id * 2];
33 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(inputs[0], norm2)(ccv_nnc_tensor_t* []){inputs[0], norm2}, (1 +1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(outputs[0])(ccv_nnc_tensor_t* []){outputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
34 return CCV_NNC_EXEC_SUCCESS;
35}
36
37static ccv_nnc_cmd_vtab_t clip_grad_norm_scatter_norm2_vtab = {
38 .exec = _ccv_cnnp_model_clip_grad_norm_scatter_norm2
39};
40
41void ccv_cnnp_model_parameters_clip_grad_norm(ccv_cnnp_model_t* const model, const ccv_cnnp_model_io_t parameters, int norm_type, float max_norm, ccv_nnc_stream_context_t* const stream_context)
42{
43 assert(norm_type == 2)((void) sizeof ((norm_type == 2) ? 1 : 0), __extension__ ({ if
(norm_type == 2) ; else __assert_fail ("norm_type == 2", "ccv_cnnp_model_addons.c"
, 43, __extension__ __PRETTY_FUNCTION__); }));
44 ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;
45 assert(compiled_data)((void) sizeof ((compiled_data) ? 1 : 0), __extension__ ({ if
(compiled_data) ; else __assert_fail ("compiled_data", "ccv_cnnp_model_addons.c"
, 45, __extension__ __PRETTY_FUNCTION__); }));
46 const int parallel_count = ccv_max(model->parallel_count, 1)({ typeof (model->parallel_count) _a = (model->parallel_count
); typeof (1) _b = (1); (_a > _b) ? _a : _b; });
47 ccv_nnc_tensor_t* norm2[parallel_count * 2];
48 ccv_nnc_tensor_t* max_normt[parallel_count];
49 const int stream_type = model->compiled_data->stream_type;
50 int i;
51 if (stream_type == CCV_STREAM_CONTEXT_GPU)
52 {
53 for (i = 0; i < parallel_count; i++)
54 {
55 ccv_nnc_tensor_param_t info = {
56 .type = CCV_TENSOR_GPU_MEMORY,
57 .format = CCV_TENSOR_FORMAT_NHWC,
58 .datatype = CCV_32F,
59 .dim = {1},
60 };
61 CCV_TENSOR_SET_DEVICE_ID(info.type, i)(info.type) = (((info.type) & ~0xfff00) | (((i) & 0xfff
) << 8));
62 norm2[i * 2] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
63 norm2[i * 2 + 1] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
64 max_normt[i] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
65 }
66 } else {
67 for (i = 0; i < parallel_count; i++)
68 {
69 ccv_nnc_tensor_param_t info = {
70 .type = CCV_TENSOR_CPU_MEMORY,
71 .format = CCV_TENSOR_FORMAT_NHWC,
72 .datatype = CCV_32F,
73 .dim = {1},
74 };
75 norm2[i * 2] = ccv_nnc_tensor_new(0, info, 0);
76 norm2[i * 2 + 1] = ccv_nnc_tensor_new(0, info, 0);
77 max_normt[i] = ccv_nnc_tensor_new(0, info, 0);
78 }
79 }
80 // zero out old norm2.
81 if (parallel_count > 1)
82 {
83 ccv_nnc_stream_context_t* streams[parallel_count];
84 ccv_nnc_stream_signal_t* signal;
85 if (stream_context)
86 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
87 for (i = 0; i < parallel_count; i++)
88 {
89 const int stream_type = CCV_TENSOR_GET_MEMORY(norm2[i * 2]->info.type)((norm2[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
90 const int device_id = CCV_TENSOR_GET_DEVICE_ID(norm2[i * 2]->info.type)(((norm2[i * 2]->info.type) & 0xfff00) >> 8);
91 int type = stream_type;
92 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
93 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
94 // Wait signal to finish.
95 if (stream_context)
96 ccv_nnc_stream_context_wait_signal(stream_0, signal);
97 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
98 if (stream_context)
99 {
100 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
101 ccv_nnc_stream_context_wait_signal(stream_context, signal);
102 }
103 streams[i] = stream_0;
104 }
105 // If this should be blocking, blocking it.
106 if (!stream_context)
107 for (i = 0; i < parallel_count; i++)
108 if (streams[i])
109 ccv_nnc_stream_context_wait(streams[i]);
110 } else {
111 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
112 }
113 // Gather norm2.
114 ccv_nnc_cmd_t reduce_cmd = {
115 .cmd = CCV_NNC_CUSTOM_FORWARD,
116 .isa = &clip_grad_norm_reduce_norm2_vtab,
117 };
118 ccv_cnnp_model_parameter_gradients_map(model, parameters, reduce_cmd, ccv_nnc_no_hint, 0, 0, 0, norm2, parallel_count * 2, stream_context);
119 // Now compute max(max_norm / norm2, 1.0).
120 if (parallel_count > 1)
121 {
122 ccv_nnc_stream_context_t* streams[parallel_count];
123 ccv_nnc_stream_signal_t* signal;
124 if (stream_context)
125 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
126 for (i = 0; i < parallel_count; i++)
127 {
128 const int stream_type = CCV_TENSOR_GET_MEMORY(norm2[i * 2]->info.type)((norm2[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
129 const int device_id = CCV_TENSOR_GET_DEVICE_ID(norm2[i * 2]->info.type)(((norm2[i * 2]->info.type) & 0xfff00) >> 8);
130 int type = stream_type;
131 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
132 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
133 // Wait signal to finish.
134 if (stream_context)
135 ccv_nnc_stream_context_wait_signal(stream_0, signal);
136 ccv_nnc_cmd_exec(CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
137 ccv_nnc_cmd_exec(CMD_SET_FORWARD(max_norm)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={max_norm,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(max_normt[i])(ccv_nnc_tensor_t* []){max_normt[i]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
138 ccv_nnc_cmd_exec(CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(max_normt[i], norm2[i * 2])(ccv_nnc_tensor_t* []){max_normt[i], norm2[i * 2]}, (1 +1 +1 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1
), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
139 ccv_nnc_cmd_exec(CMD_CLAMP_FORWARD(NAN, 1)ccv_nnc_cmd(CCV_NNC_CLAMP_FORWARD, 0, (ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.clamp={.min=(__builtin_nanf ("")),.max=1
}}, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
140 if (stream_context)
141 {
142 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
143 ccv_nnc_stream_context_wait_signal(stream_context, signal);
144 }
145 streams[i] = stream_0;
146 }
147 // If this should be blocking, blocking it.
148 if (!stream_context)
149 for (i = 0; i < parallel_count; i++)
150 if (streams[i])
151 ccv_nnc_stream_context_wait(streams[i]);
152 } else {
153 ccv_nnc_cmd_exec(CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
154 ccv_nnc_cmd_exec(CMD_SET_FORWARD(max_norm)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={max_norm,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(max_normt[0])(ccv_nnc_tensor_t* []){max_normt[0]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
155 ccv_nnc_cmd_exec(CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(max_normt[0], norm2[0])(ccv_nnc_tensor_t* []){max_normt[0], norm2[0]}, (1 +1 +1 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
156 ccv_nnc_cmd_exec(CMD_CLAMP_FORWARD(NAN, 1)ccv_nnc_cmd(CCV_NNC_CLAMP_FORWARD, 0, (ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.clamp={.min=(__builtin_nanf ("")),.max=1
}}, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
157 }
158 ccv_nnc_cmd_t scatter_cmd = {
159 .cmd = CCV_NNC_CUSTOM_FORWARD,
160 .isa = &clip_grad_norm_scatter_norm2_vtab,
161 };
162 ccv_cnnp_model_parameter_gradients_map(model, parameters, scatter_cmd, ccv_nnc_no_hint, 0, norm2, parallel_count * 2, 0, 0, stream_context);
163 if (stream_type == CCV_STREAM_CONTEXT_GPU)
164 for (i = 0; i < parallel_count; i++)
165 {
166 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, norm2[i * 2]->data.u8);
167 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, norm2[i * 2 + 1]->data.u8);
168 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, max_normt[i]->data.u8);
169 }
170 for (i = 0; i < parallel_count; i++)
171 {
172 ccv_nnc_tensor_free(norm2[i * 2]);
173 ccv_nnc_tensor_free(norm2[i * 2 + 1]);
174 ccv_nnc_tensor_free(max_normt[i]);
175 }
176}
177
178// MARK - Add-on Functions
179
180static int _ccv_cnnp_model_isnan(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
181{
182 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
183 ccv_nnc_tensor_t* const old_isnanr = outputs[1 + device_id * 2];
184 ccv_nnc_tensor_t* const isnanr = outputs[1 + device_id * 2 + 1];
185 ccv_nnc_cmd_t reduce_cmd = CMD_REDUCE_ISNAN_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_ISNAN_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
186 reduce_cmd.info.reduce.count = ccv_nnc_tensor_nd(inputs[0]->info.dim);
187 int i;
188 for (i = 0; i < cmd.info.reduce.count; i++)
189 reduce_cmd.info.reduce.axis[i] = i;
190 ccv_nnc_cmd_exec(reduce_cmd, hint, flags, TENSOR_LIST(inputs[0])(ccv_nnc_tensor_t* []){inputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(isnanr)(ccv_nnc_tensor_t* []){isnanr}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
191 ccv_nnc_cmd_exec(CMD_EWSUM_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSUM_FORWARD, 0, ccv_nnc_cmd_auto, 0), hint, flags, TENSOR_LIST(old_isnanr, isnanr)(ccv_nnc_tensor_t* []){old_isnanr, isnanr}, (1 +1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(old_isnanr)(ccv_nnc_tensor_t* []){old_isnanr}, (1 +1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
192 return CCV_NNC_EXEC_SUCCESS;
193}
194
195static ccv_nnc_cmd_vtab_t reduce_isnan_vtab = {
196 .exec = _ccv_cnnp_model_isnan
197};
198
199int ccv_cnnp_model_parameter_gradients_isnan(ccv_cnnp_model_t* const model, const ccv_cnnp_model_io_t parameters, ccv_nnc_stream_context_t* const stream_context)
200{
201 ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;
202 assert(compiled_data)((void) sizeof ((compiled_data) ? 1 : 0), __extension__ ({ if
(compiled_data) ; else __assert_fail ("compiled_data", "ccv_cnnp_model_addons.c"
, 202, __extension__ __PRETTY_FUNCTION__); }));
203 const int parallel_count = ccv_max(model->parallel_count, 1)({ typeof (model->parallel_count) _a = (model->parallel_count
); typeof (1) _b = (1); (_a > _b) ? _a : _b; });
204 ccv_nnc_tensor_t* isnanr[parallel_count * 2];
205 const int stream_type = model->compiled_data->stream_type;
206 int i;
207 if (stream_type == CCV_STREAM_CONTEXT_GPU)
208 {
209 for (i = 0; i < parallel_count; i++)
210 {
211 ccv_nnc_tensor_param_t info = {
212 .type = CCV_TENSOR_GPU_MEMORY,
213 .format = CCV_TENSOR_FORMAT_NHWC,
214 .datatype = CCV_32S,
215 .dim = {1},
216 };
217 CCV_TENSOR_SET_DEVICE_ID(info.type, i)(info.type) = (((info.type) & ~0xfff00) | (((i) & 0xfff
) << 8));
218 isnanr[i * 2] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
219 isnanr[i * 2 + 1] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
220 }
221 } else {
222 for (i = 0; i < parallel_count; i++)
223 {
224 ccv_nnc_tensor_param_t info = {
225 .type = CCV_TENSOR_CPU_MEMORY,
226 .format = CCV_TENSOR_FORMAT_NHWC,
227 .datatype = CCV_32S,
228 .dim = {1},
229 };
230 isnanr[i * 2] = ccv_nnc_tensor_new(0, info, 0);
231 isnanr[i * 2 + 1] = ccv_nnc_tensor_new(0, info, 0);
232 }
233 }
234 // zero out old isnanr.
235 if (parallel_count > 1)
236 {
237 ccv_nnc_stream_context_t* streams[parallel_count];
238 ccv_nnc_stream_signal_t* signal;
239 if (stream_context)
240 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
241 for (i = 0; i < parallel_count; i++)
242 {
243 const int stream_type = CCV_TENSOR_GET_MEMORY(isnanr[i * 2]->info.type)((isnanr[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
244 const int device_id = CCV_TENSOR_GET_DEVICE_ID(isnanr[i * 2]->info.type)(((isnanr[i * 2]->info.type) & 0xfff00) >> 8);
245 int type = stream_type;
246 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
247 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
248 // Wait signal to finish.
249 if (stream_context)
250 ccv_nnc_stream_context_wait_signal(stream_0, signal);
251 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(isnanr[i * 2])(ccv_nnc_tensor_t* []){isnanr[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
252 if (stream_context)
253 {
254 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
255 ccv_nnc_stream_context_wait_signal(stream_context, signal);
256 }
257 streams[i] = stream_0;
258 }
259 // If this should be blocking, blocking it.
260 if (!stream_context)
261 for (i = 0; i < parallel_count; i++)
262 if (streams[i])
263 ccv_nnc_stream_context_wait(streams[i]);
264 } else
265 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(isnanr[0])(ccv_nnc_tensor_t* []){isnanr[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
266 // Gather isnanr.
267 ccv_nnc_cmd_t reduce_cmd = {
268 .cmd = CCV_NNC_CUSTOM_FORWARD,
269 .isa = &reduce_isnan_vtab,
270 };
271 ccv_cnnp_model_parameter_gradients_map(model, parameters, reduce_cmd, ccv_nnc_no_hint, 0, 0, 0, isnanr, parallel_count * 2, stream_context);
272 for (i = 0; i < parallel_count; i++)
273 ccv_nnc_tensor_free(isnanr[i * 2 + 1]);
274 int retval = 0;
275 if (stream_type == CCV_TENSOR_GPU_MEMORY)
276 {
277 ccv_nnc_tensor_param_t info = {
278 .type = CCV_TENSOR_CPU_MEMORY,
279 .format = CCV_TENSOR_FORMAT_NHWC,
280 .datatype = CCV_32S,
281 .dim = {1},
282 };
283 ccv_nnc_tensor_t* checknan = ccv_nnc_tensor_new(0, info, 0);
284 for (i = 0; i < parallel_count; i++)
285 {
286 ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD()ccv_nnc_cmd(CCV_NNC_DATA_TRANSFER_FORWARD, 0, ccv_nnc_cmd_auto
, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(isnanr[i * 2])(ccv_nnc_tensor_t* []){isnanr[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(checknan)(ccv_nnc_tensor_t* []){checknan}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), 0);
287 if (checknan->data.i32[0] > 0)
288 {
289 retval = 1;
290 break;
291 }
292 }
293 ccv_nnc_tensor_free(checknan);
294 } else {
295 for (i = 0; i < parallel_count; i++)
296 if (isnanr[i * 2]->data.i32[0] > 0)
297 {
298 retval = 1;
299 break;
300 }
301 }
302 for (i = 0; i < parallel_count; i++)
303 ccv_nnc_tensor_free(isnanr[i * 2]);
304 return retval;
305}
306
307// MARK - Core Layers
308
309static void _ccv_cnnp_sum_build(ccv_cnnp_model_t* const self, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
310{
311 PRINT(CCV_CLI_VERBOSE, "[cnnp_sum_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sum_build] -\n"); fflush(stdout); } } while (
0);
312 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 312, __extension__ __PRETTY_FUNCTION__
); }));
313 outputs[0] = ccv_nnc_tensor_symbol_new(graph, ccv_nnc_tensor_symbol_params(graph, inputs[0]), 0);
314 ccv_nnc_graph_exec_symbol_new(graph, CMD_EWSUM_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSUM_FORWARD, 0, ccv_nnc_cmd_auto, 0), inputs, input_size, outputs, output_size, 0);
315}
316
317static ccv_cnnp_model_t* _ccv_cnnp_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
318
319static const ccv_cnnp_model_vtab_t ccv_cnnp_sum_isa = {
320 .build = _ccv_cnnp_sum_build,
321 .copy = _ccv_cnnp_sum_copy,
322};
323
324typedef struct {
325 ccv_cnnp_model_t super;
326 ccv_nnc_tensor_symbol_t output;
327} ccv_cnnp_model_sum_t;
328
329ccv_cnnp_model_t* ccv_cnnp_sum(const char* const name)
330{
331 ccv_cnnp_model_sum_t* const model_sum = (ccv_cnnp_model_sum_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sum_t));
332 model_sum->super.isa = &ccv_cnnp_sum_isa;
333 model_sum->super.input_size = 0;
334 model_sum->super.outputs = &model_sum->output;
335 model_sum->super.output_size = 1;
336 ccv_cnnp_model_copy_name(&model_sum->super, name);
337 return (ccv_cnnp_model_t*)model_sum;
338}
339
340static ccv_cnnp_model_t* _ccv_cnnp_sum_copy(const ccv_cnnp_model_t* const self, void* const context)
341{
342 return ccv_cnnp_sum(self->name);
343}
344
345typedef struct {
346 ccv_cnnp_model_t super;
347 int axis;
348 ccv_nnc_tensor_symbol_t output;
349} ccv_cnnp_model_concat_t;
350
351static void _ccv_cnnp_concat_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
352{
353 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
354 PRINT(CCV_CLI_VERBOSE, "[cnnp_concat_build] 1. -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_concat_build] 1. -\n"); fflush(stdout); } } while
(0);
355 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 355, __extension__ __PRETTY_FUNCTION__
); }));
356 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
357 int i, j;
358 if (output_params.dim[0] == 0)
359 for (i = 1; i < input_size; i++)
360 {
361 output_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
362 if (output_params.dim[0] != 0)
363 break;
364 }
365 const int nd = ccv_nnc_tensor_nd(output_params.dim);
366 const int axis = self->axis;
367 assert(axis < nd)((void) sizeof ((axis < nd) ? 1 : 0), __extension__ ({ if (
axis < nd) ; else __assert_fail ("axis < nd", "ccv_cnnp_model_addons.c"
, 367, __extension__ __PRETTY_FUNCTION__); }));
368 output_params.dim[axis] = 0;
369 int input_is_contiguous = 1;
370 for (i = 0; i < input_size; i++)
371 {
372 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
373 const int input_nd = ccv_nnc_tensor_nd(input_params.dim);
374 if (input_nd == 0)
375 {
376 PRINT(CCV_CLI_VERBOSE, "[cnnp_concat_build] %d. input[%d]: -\n", i + 2, i)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_concat_build] %d. input[%d]: -\n", i + 2, i)
; fflush(stdout); } } while (0);
377 input_is_contiguous = 0;
378 continue;
379 }
380 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
381 {
382 PRINT(CCV_CLI_VERBOSE, "[cnnp_concat_build] %d. input[%d]: (%d", i + 2, i, input_params.dim[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_concat_build] %d. input[%d]: (%d", i + 2, i,
input_params.dim[0]); fflush(stdout); } } while (0);
383 int i;
384 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && input_params.dim[i] > 0; i++)
385 PRINT(CCV_CLI_VERBOSE, ", %d", input_params.dim[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", input_params.dim[i]); fflush(stdout); } } while
(0);
386 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
387 }
388 assert(input_nd == nd)((void) sizeof ((input_nd == nd) ? 1 : 0), __extension__ ({ if
(input_nd == nd) ; else __assert_fail ("input_nd == nd", "ccv_cnnp_model_addons.c"
, 388, __extension__ __PRETTY_FUNCTION__); }));
389 for (j = 0; j < nd; j++)
390 if (j != axis)
391 { assert(input_params.dim[j] == output_params.dim[j])((void) sizeof ((input_params.dim[j] == output_params.dim[j])
? 1 : 0), __extension__ ({ if (input_params.dim[j] == output_params
.dim[j]) ; else __assert_fail ("input_params.dim[j] == output_params.dim[j]"
, "ccv_cnnp_model_addons.c", 391, __extension__ __PRETTY_FUNCTION__
); })); }
392 output_params.dim[axis] += input_params.dim[axis];
393 }
394 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
395 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
396 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
397 ccv_nnc_tensor_get_stride(output_params.dim, stride);
398 if (input_is_contiguous)
399 {
400 ccv_nnc_tensor_symbol_t aliases[input_size];
401 for (i = 0; i < input_size; i++)
402 {
403 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
404 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
405 ofs[axis] += input_params.dim[axis];
406 }
407 // Format transform is more flexible.
408 ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, input_size, aliases, input_size, "concat");
409 } else {
410 ccv_nnc_tensor_symbol_t aliases[input_size];
411 for (i = 0; i < input_size; i++)
412 {
413 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
414 if (input_params.dim[0] == 0)
415 {
416 // Create a new alias anyway, but not going to use it, in this way, the alias count will match during absorb.
417 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
418 continue;
419 }
420 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
421 ofs[axis] += input_params.dim[axis];
422 }
423 // Format transform is more flexible.
424 ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, input_size, aliases, input_size, "concat");
425 }
426}
427
428static ccv_cnnp_model_t* _ccv_cnnp_concat_copy(const ccv_cnnp_model_t* const self, void* const context);
429
430static const ccv_cnnp_model_vtab_t ccv_cnnp_concat_isa = {
431 .build = _ccv_cnnp_concat_build,
432 .copy = _ccv_cnnp_concat_copy,
433};
434
435ccv_cnnp_model_t* ccv_cnnp_concat(const int axis, const char* const name)
436{
437 ccv_cnnp_model_concat_t* const model_concat = (ccv_cnnp_model_concat_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_concat_t));
438 model_concat->super.isa = &ccv_cnnp_concat_isa;
439 model_concat->super.input_size = 0;
440 model_concat->super.outputs = &model_concat->output;
441 model_concat->super.output_size = 1;
442 model_concat->axis = axis;
443 ccv_cnnp_model_copy_name(&model_concat->super, name);
444 return (ccv_cnnp_model_t*)model_concat;
445}
446
447static ccv_cnnp_model_t* _ccv_cnnp_concat_copy(const ccv_cnnp_model_t* const super, void* const context)
448{
449 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
450 return ccv_cnnp_concat(self->axis, self->super.name);
451}
452
453typedef struct {
454 ccv_cnnp_model_t super;
455 int axis;
456 ccv_nnc_tensor_symbol_t outputs[1];
457} ccv_cnnp_model_chunk_t;
458
459static void _ccv_cnnp_chunk_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
460{
461 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
462 PRINT(CCV_CLI_VERBOSE, "[cnnp_chunk_build] 1. axis: %d\n", self->axis)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_chunk_build] 1. axis: %d\n", self->axis);
fflush(stdout); } } while (0);
463 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 463, __extension__ __PRETTY_FUNCTION__); }));
464 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
465 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
466 {
467 PRINT(CCV_CLI_VERBOSE, "[cnnp_chunk_build] 2. input: (%d", input_params.dim[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_chunk_build] 2. input: (%d", input_params.dim
[0]); fflush(stdout); } } while (0);
468 int i;
469 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && input_params.dim[i] > 0; i++)
470 PRINT(CCV_CLI_VERBOSE, ", %d", input_params.dim[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", input_params.dim[i]); fflush(stdout); } } while
(0);
471 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
472 }
473 ccv_nnc_tensor_param_t output_params = input_params;
474 int i;
475 const int nd = ccv_nnc_tensor_nd(output_params.dim);
476 const int axis = self->axis;
477 assert(axis < nd)((void) sizeof ((axis < nd) ? 1 : 0), __extension__ ({ if (
axis < nd) ; else __assert_fail ("axis < nd", "ccv_cnnp_model_addons.c"
, 477, __extension__ __PRETTY_FUNCTION__); }));
478 const int n = self->super.output_size;
479 assert(n == output_size)((void) sizeof ((n == output_size) ? 1 : 0), __extension__ ({
if (n == output_size) ; else __assert_fail ("n == output_size"
, "ccv_cnnp_model_addons.c", 479, __extension__ __PRETTY_FUNCTION__
); }));
480 assert(output_params.dim[axis] % n == 0)((void) sizeof ((output_params.dim[axis] % n == 0) ? 1 : 0), __extension__
({ if (output_params.dim[axis] % n == 0) ; else __assert_fail
("output_params.dim[axis] % n == 0", "ccv_cnnp_model_addons.c"
, 480, __extension__ __PRETTY_FUNCTION__); }));
481 output_params.dim[axis] = output_params.dim[axis] / n;
482 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
483 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
484 ccv_nnc_tensor_get_stride(input_params.dim, stride);
485 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
486 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
487 {
488 for (i = 0; i < output_size; i++)
489 {
490 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
491 ofs[axis] += output_params.dim[axis];
492 }
493 } else {
494 // Otherwise, we need to check if it is permute. For permute, we cannot do alias directly.
495 // We need to first materialize the permute and then run reshape on top of it, otherwise it will be wrong.
496 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
497 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
498 // We identify permute by checking if the stride is not in descending order.
499 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
500 int i, no_permute = 1;
501 for (i = 1; no_permute && i < nd; i++)
502 if (old_stride[i - 1] < old_stride[i])
503 no_permute = 0;
504 if (no_permute)
505 { // Just straightforward reshape if there is no no permute.
506 for (i = 0; i < output_size; i++)
507 {
508 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, old_stride, output_params, 0);
509 ofs[axis] += output_params.dim[axis];
510 }
511 } else {
512 // Otherwise, we first do format transform to plain tensor and then do reshape.
513 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, input_params, 0);
514 ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(permuted)(const ccv_nnc_tensor_symbol_t []){permuted}, (1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "reshape");
515 for (i = 0; i < output_size; i++)
516 {
517 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, ofs, stride, output_params, 0);
518 ofs[axis] += output_params.dim[axis];
519 }
520 }
521 }
522}
523
524static ccv_cnnp_model_t* _ccv_cnnp_chunk_copy(const ccv_cnnp_model_t* const self, void* const context);
525
526static const ccv_cnnp_model_vtab_t ccv_cnnp_chunk_isa = {
527 .build = _ccv_cnnp_chunk_build,
528 .copy = _ccv_cnnp_chunk_copy,
529};
530
531ccv_cnnp_model_t* ccv_cnnp_chunk(const int n, const int axis, const char* const name)
532{
533 assert(n >= 1)((void) sizeof ((n >= 1) ? 1 : 0), __extension__ ({ if (n >=
1) ; else __assert_fail ("n >= 1", "ccv_cnnp_model_addons.c"
, 533, __extension__ __PRETTY_FUNCTION__); }));
534 ccv_cnnp_model_chunk_t* const model_chunk = (ccv_cnnp_model_chunk_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_chunk_t) + sizeof(ccv_nnc_tensor_symbol_t) * (n - 1));
535 model_chunk->super.isa = &ccv_cnnp_chunk_isa;
536 model_chunk->super.input_size = 1;
537 model_chunk->super.outputs = model_chunk->outputs;
538 model_chunk->super.output_size = n;
539 model_chunk->axis = axis;
540 ccv_cnnp_model_copy_name(&model_chunk->super, name);
541 return (ccv_cnnp_model_t*)model_chunk;
542}
543
544static ccv_cnnp_model_t* _ccv_cnnp_chunk_copy(const ccv_cnnp_model_t* const super, void* const context)
545{
546 const ccv_cnnp_model_chunk_t* const self = (const ccv_cnnp_model_chunk_t*)super;
547 return ccv_cnnp_chunk(self->super.output_size, self->axis, self->super.name);
548}
549
550typedef struct {
551 ccv_cnnp_model_t super;
552 ccv_nnc_tensor_symbol_t output;
553 int format;
554 int dim[CCV_NNC_MAX_DIM_ALLOC(12)];
555 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
556 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
557} ccv_cnnp_model_reshape_t;
558
559static void _ccv_cnnp_reshape_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
560{
561 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 561, __extension__ __PRETTY_FUNCTION__); }));
562 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 562, __extension__ __PRETTY_FUNCTION__
); }));
563 ccv_cnnp_model_reshape_t* const self = (ccv_cnnp_model_reshape_t*)super;
564 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
565 {
566 PRINT(CCV_CLI_VERBOSE, "[cnnp_reshape_build] 1. dim: (%d", self->dim[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reshape_build] 1. dim: (%d", self->dim[0]
); fflush(stdout); } } while (0);
567 int i;
568 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && self->dim[i] > 0; i++)
569 PRINT(CCV_CLI_VERBOSE, ", %d", self->dim[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", self->dim[i]); fflush(stdout); } } while
(0);
570 const int count = i;
571 PRINT(CCV_CLI_VERBOSE, "), ofs: (%d", self->ofs[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("), ofs: (%d", self->ofs[0]); fflush(stdout); } }
while (0);
572 for (i = 1; i < count; i++)
573 PRINT(CCV_CLI_VERBOSE, ", %d", self->ofs[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", self->ofs[i]); fflush(stdout); } } while
(0);
574 PRINT(CCV_CLI_VERBOSE, "), stride: (%d", self->stride[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("), stride: (%d", self->stride[0]); fflush(stdout
); } } while (0);
575 for (i = 1; i < count; i++)
576 PRINT(CCV_CLI_VERBOSE, ", %d", self->stride[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", self->stride[i]); fflush(stdout); } } while
(0);
577 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
578 }
579 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
580 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
581 {
582 PRINT(CCV_CLI_VERBOSE, "[cnnp_reshape_build] 2. input: (%d", params.dim[0])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reshape_build] 2. input: (%d", params.dim[0]
); fflush(stdout); } } while (0);
583 int i;
584 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && params.dim[i] > 0; i++)
585 PRINT(CCV_CLI_VERBOSE, ", %d", params.dim[i])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(", %d", params.dim[i]); fflush(stdout); } } while (
0);
586 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
587 }
588 assert(ccv_nnc_dimension_count(self->dim) <= ccv_nnc_tensor_count(params))((void) sizeof ((ccv_nnc_dimension_count(self->dim) <= ccv_nnc_tensor_count
(params)) ? 1 : 0), __extension__ ({ if (ccv_nnc_dimension_count
(self->dim) <= ccv_nnc_tensor_count(params)) ; else __assert_fail
("ccv_nnc_dimension_count(self->dim) <= ccv_nnc_tensor_count(params)"
, "ccv_cnnp_model_addons.c", 588, __extension__ __PRETTY_FUNCTION__
); }));
589 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
590 int stride_from_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
591 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
592 {
593 memcpy(params.dim, self->dim, sizeof(params.dim));
594 int* stride;
595 if (self->stride[0] == 0)
596 {
597 ccv_nnc_tensor_get_stride(self->dim, stride_from_dim);
598 stride = stride_from_dim;
599 } else
600 stride = self->stride;
601 if (self->format > 0)
602 params.format = self->format;
603 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
604 } else {
605 // Otherwise, we need to check if it is permute. For permute, we cannot do alias directly.
606 // We need to first materialize the permute and then run reshape on top of it, otherwise it will be wrong.
607 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
608 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
609 // We identify permute by checking if the stride is not in descending order.
610 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
611 const int nd = ccv_nnc_tensor_nd(params.dim);
612 const int new_nd = ccv_nnc_tensor_nd(self->dim);
613 int i, no_permute = 1;
614 // If the new dim has different nd, or we actually have a stride, we need to check if it is no permute or not.
615 if (new_nd != nd || (self->stride[0] != 0 && memcmp(self->stride, old_stride, sizeof(self->stride))))
616 for (i = 1; no_permute && i < nd; i++)
617 if (old_stride[i - 1] < old_stride[i])
618 no_permute = 0;
619 if (no_permute)
620 { // Just straightforward reshape if there is no no permute.
621 memcpy(params.dim, self->dim, sizeof(params.dim));
622 int* stride;
623 if (self->stride[0] == 0)
624 {
625 if (new_nd != nd) // Cannot use old stride.
626 {
627 ccv_nnc_tensor_get_stride(self->dim, stride_from_dim);
628 stride = stride_from_dim;
629 } else
630 stride = old_stride;
631 } else
632 stride = self->stride;
633 if (self->format > 0)
634 params.format = self->format;
635 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
636 } else {
637 // Otherwise, we first do format transform to plain tensor and then do reshape.
638 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, params, 0);
639 ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(permuted)(const ccv_nnc_tensor_symbol_t []){permuted}, (1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "reshape");
640 memcpy(params.dim, self->dim, sizeof(params.dim));
641 int* stride;
642 if (self->stride[0] == 0)
643 {
644 ccv_nnc_tensor_get_stride(self->dim, stride_from_dim);
645 stride = stride_from_dim;
646 } else
647 stride = self->stride;
648 if (self->format > 0)
649 params.format = self->format;
650 // And then we create alias against the permuted one.
651 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, self->ofs, stride, params, 0);
652 }
653 }
654}
655
656static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context);
657
658static const ccv_cnnp_model_vtab_t ccv_cnnp_reshape_isa = {
659 .build = _ccv_cnnp_reshape_build,
660 .copy = _ccv_cnnp_reshape_copy,
661};
662
663ccv_cnnp_model_t* ccv_cnnp_reshape(const int format, const int dim[CCV_NNC_MAX_DIM_ALLOC(12)], const int ofs[CCV_NNC_MAX_DIM_ALLOC(12)], const int stride[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
664{
665 ccv_cnnp_model_reshape_t* const model_reshape = (ccv_cnnp_model_reshape_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reshape_t));
666 model_reshape->super.isa = &ccv_cnnp_reshape_isa;
667 model_reshape->super.input_size = 1;
668 model_reshape->super.outputs = &model_reshape->output;
669 model_reshape->super.output_size = 1;
670 ccv_cnnp_model_copy_name(&model_reshape->super, name);
671 model_reshape->format = format;
672 memcpy(model_reshape->dim, dim, sizeof(model_reshape->dim));
673 memcpy(model_reshape->ofs, ofs, sizeof(model_reshape->ofs));
674 if (stride[0] != 0)
675 memcpy(model_reshape->stride, stride, sizeof(model_reshape->stride));
676 return (ccv_cnnp_model_t*)model_reshape;
677}
678
679static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context)
680{
681 const ccv_cnnp_model_reshape_t* const self = (const ccv_cnnp_model_reshape_t*)super;
682 return ccv_cnnp_reshape(self->format, self->dim, self->ofs, self->stride, self->super.name);
683}
684
685typedef struct {
686 ccv_cnnp_model_t super;
687 ccv_nnc_tensor_symbol_t output;
688 int type;
689 int begin[CCV_NNC_MAX_DIM_ALLOC(12)];
690 int end[CCV_NNC_MAX_DIM_ALLOC(12)];
691} ccv_cnnp_model_pad_t;
692
693static void _ccv_cnnp_pad_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
694{
695 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 695, __extension__ __PRETTY_FUNCTION__); }));
696 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 696, __extension__ __PRETTY_FUNCTION__
); }));
697 ccv_cnnp_model_pad_t* const self = (ccv_cnnp_model_pad_t*)super;
698 PRINT(CCV_CLI_VERBOSE, "[cnnp_pad_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_pad_build] -\n"); fflush(stdout); } } while (
0);
699 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
700 const int nd = ccv_nnc_tensor_nd(input_params.dim);
701 ccv_nnc_tensor_param_t params = input_params;
702 int i;
703 for (i = 0 ; i < nd; i++)
704 params.dim[i] += self->begin[i] + self->end[i];
705 const ccv_nnc_tensor_symbol_t padded = ccv_nnc_tensor_symbol_new(graph, params, 0);
706 ccv_nnc_cmd_t pad = CMD_PAD_FORWARD(self->type, (), ())ccv_nnc_cmd(CCV_NNC_PAD_FORWARD, 0, ((ccv_nnc_cmd_param_t){.size
={.dim={}},.pad={.type=self->type,.end={}}}), 0);
707 memcpy(pad.info.size.dim, self->begin, sizeof(pad.info.size.dim));
708 memcpy(pad.info.pad.end, self->end, sizeof(pad.info.pad.end));
709 ccv_nnc_graph_exec_symbol_new(graph, pad, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(padded)(const ccv_nnc_tensor_symbol_t []){padded}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "pad");
710 outputs[0] = padded;
711}
712
713static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context);
714
715static const ccv_cnnp_model_vtab_t ccv_cnnp_pad_isa = {
716 .build = _ccv_cnnp_pad_build,
717 .copy = _ccv_cnnp_pad_copy,
718};
719
720ccv_cnnp_model_t* ccv_cnnp_pad(const int type, const int begin[CCV_NNC_MAX_DIM_ALLOC(12)], const int end[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
721{
722 ccv_cnnp_model_pad_t* const model_pad = (ccv_cnnp_model_pad_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pad_t));
723 model_pad->super.isa = &ccv_cnnp_pad_isa;
724 model_pad->super.input_size = 1;
725 model_pad->super.outputs = &model_pad->output;
726 model_pad->super.output_size = 1;
727 ccv_cnnp_model_copy_name(&model_pad->super, name);
728 model_pad->type = type;
729 memcpy(model_pad->begin, begin, sizeof(model_pad->begin));
730 memcpy(model_pad->end, end, sizeof(model_pad->end));
731 return (ccv_cnnp_model_t*)model_pad;
732}
733
734static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context)
735{
736 const ccv_cnnp_model_pad_t* const self = (const ccv_cnnp_model_pad_t*)super;
737 return ccv_cnnp_pad(self->type, self->begin, self->end, self->super.name);
738}
739
740typedef struct {
741 ccv_cnnp_model_t super;
742 ccv_nnc_tensor_symbol_t output;
743} ccv_cnnp_model_identity_t;
744
745static void _ccv_cnnp_identity_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
746{
747 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 747, __extension__ __PRETTY_FUNCTION__); }));
748 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 748, __extension__ __PRETTY_FUNCTION__
); }));
749 PRINT(CCV_CLI_VERBOSE, "[cnnp_identity_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_identity_build] -\n"); fflush(stdout); } } while
(0);
750 outputs[0] = inputs[0];
751}
752
753static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context);
754
755static const ccv_cnnp_model_vtab_t ccv_cnnp_identity_isa = {
756 .build = _ccv_cnnp_identity_build,
757 .copy = _ccv_cnnp_identity_copy,
758};
759
760ccv_cnnp_model_t* ccv_cnnp_identity(const char* const name)
761{
762 ccv_cnnp_model_identity_t* const model_identity = (ccv_cnnp_model_identity_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_identity_t));
763 model_identity->super.isa = &ccv_cnnp_identity_isa;
764 model_identity->super.input_size = 1;
765 model_identity->super.outputs = &model_identity->output;
766 model_identity->super.output_size = 1;
767 ccv_cnnp_model_copy_name(&model_identity->super, name);
768 return (ccv_cnnp_model_t*)model_identity;
769}
770
771static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context)
772{
773 const ccv_cnnp_model_identity_t* const self = (const ccv_cnnp_model_identity_t*)super;
774 return ccv_cnnp_identity(self->super.name);
775}
776
777typedef struct {
778 ccv_cnnp_model_t super;
779 ccv_nnc_tensor_symbol_t output;
780 int index[CCV_NNC_MAX_DIM_ALLOC(12)];
781} ccv_cnnp_model_permute_t;
782
783static void _ccv_cnnp_permute_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
784{
785 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 785, __extension__ __PRETTY_FUNCTION__); }));
786 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 786, __extension__ __PRETTY_FUNCTION__
); }));
787 ccv_cnnp_model_permute_t* const self = (ccv_cnnp_model_permute_t*)super;
788 PRINT(CCV_CLI_VERBOSE, "[cnnp_permute_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_permute_build] -\n"); fflush(stdout); } } while
(0);
789 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
790 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
791 const int nd = ccv_nnc_tensor_nd(params.dim);
792 int input_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
793 memcpy(input_dim, params.dim, sizeof(params.dim));
794 int input_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
795 int output_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
796 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If it is not an alias. Find stride and permute.
797 {
798 ccv_nnc_tensor_get_stride(input_dim, input_stride);
799 int i;
800 for (i = 0; i < nd; i++)
801 {
802 const int idx = self->index[i];
803 assert(idx >= 0 && idx < nd)((void) sizeof ((idx >= 0 && idx < nd) ? 1 : 0)
, __extension__ ({ if (idx >= 0 && idx < nd) ; else
__assert_fail ("idx >= 0 && idx < nd", "ccv_cnnp_model_addons.c"
, 803, __extension__ __PRETTY_FUNCTION__); }));
804 params.dim[i] = input_dim[idx];
805 output_stride[i] = input_stride[idx];
806 }
807 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ccv_nnc_no_ofs, output_stride, params, 0);
808 } else {
809 // if it is an alias, we can get the stride from it and use that.
810 int input_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
811 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], input_ofs, input_stride);
812 assert(input_stride[0] != 0)((void) sizeof ((input_stride[0] != 0) ? 1 : 0), __extension__
({ if (input_stride[0] != 0) ; else __assert_fail ("input_stride[0] != 0"
, "ccv_cnnp_model_addons.c", 812, __extension__ __PRETTY_FUNCTION__
); }));
813 int output_ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
814 int i;
815 for (i = 0; i < nd; i++)
816 {
817 const int idx = self->index[i];
818 assert(idx >= 0 && idx < nd)((void) sizeof ((idx >= 0 && idx < nd) ? 1 : 0)
, __extension__ ({ if (idx >= 0 && idx < nd) ; else
__assert_fail ("idx >= 0 && idx < nd", "ccv_cnnp_model_addons.c"
, 818, __extension__ __PRETTY_FUNCTION__); }));
819 params.dim[i] = input_dim[idx];
820 output_stride[i] = input_stride[idx];
821 output_ofs[i] = input_ofs[idx];
822 }
823 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], output_ofs, output_stride, params, 0);
824 }
825}
826
827static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context);
828
829static const ccv_cnnp_model_vtab_t ccv_cnnp_permute_isa = {
830 .build = _ccv_cnnp_permute_build,
831 .copy = _ccv_cnnp_permute_copy,
832};
833
834ccv_cnnp_model_t* ccv_cnnp_permute(const int index[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
835{
836 ccv_cnnp_model_permute_t* const model_permute = (ccv_cnnp_model_permute_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_permute_t));
837 model_permute->super.isa = &ccv_cnnp_permute_isa;
838 model_permute->super.input_size = 1;
839 model_permute->super.outputs = &model_permute->output;
840 model_permute->super.output_size = 1;
841 ccv_cnnp_model_copy_name(&model_permute->super, name);
842 memcpy(model_permute->index, index, sizeof(model_permute->index));
843 return (ccv_cnnp_model_t*)model_permute;
844}
845
846static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context)
847{
848 const ccv_cnnp_model_permute_t* const self = (const ccv_cnnp_model_permute_t*)super;
849 return ccv_cnnp_permute(self->index, self->super.name);
850}
851
852typedef struct {
853 ccv_cnnp_model_t super;
854 int index;
855 ccv_nnc_tensor_symbol_t output;
856} ccv_cnnp_model_extract_t;
857
858static void _ccv_cnnp_extract_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
859{
860 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 860, __extension__ __PRETTY_FUNCTION__
); }));
861 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
862 PRINT(CCV_CLI_VERBOSE, "[cnnp_extract_build] index: %d\n", self->index)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_extract_build] index: %d\n", self->index)
; fflush(stdout); } } while (0);
863 outputs[0] = inputs[self->index];
864}
865
866static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const self, void* const context);
867
868static const ccv_cnnp_model_vtab_t ccv_cnnp_extract_isa = {
869 .build = _ccv_cnnp_extract_build,
870 .copy = _ccv_cnnp_extract_copy,
871};
872
873ccv_cnnp_model_t* ccv_cnnp_extract(const int index, const char* const name)
874{
875 ccv_cnnp_model_extract_t* const model_extract = (ccv_cnnp_model_extract_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_extract_t));
876 model_extract->index = index;
877 model_extract->super.isa = &ccv_cnnp_extract_isa;
878 model_extract->super.input_size = 0;
879 model_extract->super.outputs = &model_extract->output;
880 model_extract->super.output_size = 1;
881 ccv_cnnp_model_copy_name(&model_extract->super, name);
882 return (ccv_cnnp_model_t*)model_extract;
883}
884
885static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const super, void* const context)
886{
887 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
888 return ccv_cnnp_extract(self->index, self->super.name);
889}
890
891typedef struct {
892 ccv_cnnp_model_t super;
893 ccv_nnc_tensor_symbol_t output;
894} ccv_cnnp_model_flatten_t;
895
896static void _ccv_cnnp_flatten_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
897{
898 PRINT(CCV_CLI_VERBOSE, "[cnnp_flatten_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_flatten_build] -\n"); fflush(stdout); } } while
(0);
899 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 899, __extension__ __PRETTY_FUNCTION__); }));
900 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 900, __extension__ __PRETTY_FUNCTION__
); }));
901 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
902 ccv_nnc_tensor_param_t output_params = params;
903 memset(output_params.dim, 0, sizeof(output_params.dim));
904 output_params.dim[0] = ccv_nnc_tensor_get_n(params);
905 assert(output_params.dim[0] > 0)((void) sizeof ((output_params.dim[0] > 0) ? 1 : 0), __extension__
({ if (output_params.dim[0] > 0) ; else __assert_fail ("output_params.dim[0] > 0"
, "ccv_cnnp_model_addons.c", 905, __extension__ __PRETTY_FUNCTION__
); }));
906 output_params.dim[1] = ccv_nnc_tensor_count(params) / output_params.dim[0];
907 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
908 ccv_nnc_tensor_get_stride(output_params.dim, stride);
909 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], DIM_ALLOC()(int [(12)]){}, stride, output_params, 0);
910}
911
912static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context);
913
914static const ccv_cnnp_model_vtab_t ccv_cnnp_flatten_isa = {
915 .build = _ccv_cnnp_flatten_build,
916 .copy = _ccv_cnnp_flatten_copy,
917};
918
919ccv_cnnp_model_t* ccv_cnnp_flatten(const char* const name)
920{
921 ccv_cnnp_model_flatten_t* const model_flatten = (ccv_cnnp_model_flatten_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_flatten_t));
922 model_flatten->super.isa = &ccv_cnnp_flatten_isa;
923 model_flatten->super.input_size = 1;
924 model_flatten->super.outputs = &model_flatten->output;
925 model_flatten->super.output_size = 1;
926 ccv_cnnp_model_copy_name(&model_flatten->super, name);
927 return (ccv_cnnp_model_t*)model_flatten;
928}
929
930static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context)
931{
932 return ccv_cnnp_flatten(self->name);
933}
934
935// MARK - Batch Norm Layer
936
937typedef struct {
938 ccv_cnnp_model_t super;
939 ccv_nnc_tensor_symbol_t output;
940 ccv_nnc_tensor_symbol_t bias;
941 ccv_nnc_tensor_symbol_t scale;
942 ccv_nnc_graph_exec_symbol_t batch_norm;
943 ccv_nnc_cmd_param_t params;
944 ccv_array_t* zero_inits;
945 ccv_array_t* retainables;
946} ccv_cnnp_model_batch_norm_t;
947
948static void _ccv_cnnp_batch_norm_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
949{
950 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 950, __extension__ __PRETTY_FUNCTION__); }));
951 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 951, __extension__ __PRETTY_FUNCTION__
); }));
952 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
953 PRINT(CCV_CLI_VERBOSE, "[cnnp_batch_norm_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_batch_norm_build] -\n"); fflush(stdout); } }
while (0);
954 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
955 const int nd = ccv_nnc_tensor_nd(params.dim);
956 ccv_nnc_tensor_param_t bias_params = params;
957 memset(bias_params.dim, 0, sizeof(bias_params.dim));
958 // If the accuracy is not enough, bump it to 32-bit floating point.
959 if (bias_params.datatype != CCV_32F && bias_params.datatype != CCV_64F)
960 bias_params.datatype = CCV_32F;
961 bias_params.dim[0] = nd > 1 ? ccv_nnc_tensor_get_c(params) : params.dim[0];
962 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, params, 0);
963 // Both scale and bias are shared between if this model is reused.
964 if (!self->scale.graph)
965 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
966 if (!self->bias.graph)
967 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
968 const ccv_nnc_tensor_symbol_t mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "mean");
969 const ccv_nnc_tensor_symbol_t var = ccv_nnc_tensor_symbol_new(graph, bias_params, "var");
970 // Otherwise, notice mean, var, saved_mean, saved_inv_std are not reused.
971 if (!self->zero_inits)
972 self->zero_inits = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
973 ccv_array_push(self->zero_inits, &mean);
974 ccv_array_push(self->zero_inits, &var);
975 const ccv_nnc_tensor_symbol_t out_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_mean");
976 const ccv_nnc_tensor_symbol_t out_var = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_var");
977 if (!self->retainables)
978 self->retainables = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
979 ccv_array_push(self->retainables, &out_mean);
980 ccv_array_push(self->retainables, &out_var);
981 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_mean");
982 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_inv_std");
983 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
984 ccv_nnc_cmd_param_t batch_norm = self->params;
985 batch_norm.bnorm.count = hw >= 0 ? CCV_NNC_MAX_DIM(2) + 1 : 1;
986 int i;
987 batch_norm.bnorm.axis[0] = (params.format == CCV_TENSOR_FORMAT_CHWN) ? 3 : 0;
988 if (hw >= 0)
989 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
990 batch_norm.bnorm.axis[i + 1] = i + hw;
991 self->params = batch_norm;
992 self->batch_norm = ccv_nnc_graph_exec_symbol_new(graph, ccv_nnc_cmd(CCV_NNC_BATCH_NORM_FORWARD, 0, batch_norm, 0), TENSOR_SYMBOL_LIST(inputs[0], self->scale, self->bias, mean, var)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->scale,
self->bias, mean, var}, (1 +1 +1 +1 +1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, out_mean, out_var, saved_mean, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, out_mean, out_var,
saved_mean, saved_inv_std}, (1 +1 +1 +1 +1 +1 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "batch_norm");
993 outputs[0] = output;
994}
995
996static void _ccv_cnnp_batch_norm_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
997{
998 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
999 if (self->scale.graph)
1000 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(0, 1)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={0, 1}}}, 0), ccv_nnc_no_hint, 0, 0, self->scale);
1001 if (self->bias.graph)
1002 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
1003 int i;
1004 if (self->zero_inits)
1005 for (i = 0; i < self->zero_inits->rnum; i++)
1006 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, *(ccv_nnc_tensor_symbol_t*)ccv_array_get(self->zero_inits, i)((void*)(((char*)((self->zero_inits)->data)) + (size_t)
(self->zero_inits)->rsize * (size_t)(i))));
1007}
1008
1009static void _ccv_cnnp_batch_norm_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
1010{
1011 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1012 if (self->scale.graph)
1013 add_to_array(parameters, self->scale, is_trainable);
1014 if (self->bias.graph)
1015 add_to_array(parameters, self->bias, is_trainable);
1016}
1017
1018static void _ccv_cnnp_batch_norm_add_to_output(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const outputs)
1019{
1020 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1021 int i;
1022 if (self->retainables)
1023 for (i = 0; i < self->retainables->rnum; i++)
1024 {
1025 const ccv_nnc_tensor_symbol_t symbol = *(ccv_nnc_tensor_symbol_t*)ccv_array_get(self->retainables, i)((void*)(((char*)((self->retainables)->data)) + (size_t
)(self->retainables)->rsize * (size_t)(i)));
1026 add_to_array(outputs, symbol, 0);
1027 }
1028}
1029
1030static void _ccv_cnnp_batch_norm_set_is_test(ccv_cnnp_model_t* const super, const int is_test, const ccv_cnnp_cmd_updater_f updater, void* const context)
1031{
1032 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1033 if (self->batch_norm.graph)
1034 {
1035 self->params.bnorm.is_test = is_test;
1036 updater(context, self->batch_norm, ccv_nnc_cmd(CCV_NNC_BATCH_NORM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
1037 }
1038}
1039
1040static void _ccv_cnnp_batch_norm_deinit(ccv_cnnp_model_t* const super)
1041{
1042 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1043 if (self->zero_inits)
1044 ccv_array_free(self->zero_inits);
1045 if (self->retainables)
1046 ccv_array_free(self->retainables);
1047}
1048
1049static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
1050
1051static const ccv_cnnp_model_vtab_t ccv_cnnp_batch_norm_isa = {
1052 .build = _ccv_cnnp_batch_norm_build,
1053 .init_states = _ccv_cnnp_batch_norm_init_states,
1054 .add_to_parameter = _ccv_cnnp_batch_norm_add_to_parameter,
1055 .add_to_output = _ccv_cnnp_batch_norm_add_to_output,
1056 .copy = _ccv_cnnp_batch_norm_copy,
1057 .set_is_test = _ccv_cnnp_batch_norm_set_is_test,
1058 .deinit = _ccv_cnnp_batch_norm_deinit,
1059};
1060
1061ccv_cnnp_model_t* ccv_cnnp_batch_norm(const float momentum, const float epsilon, const int is_trainable, const char* const name)
1062{
1063 ccv_cnnp_model_batch_norm_t* const model_batch_norm = (ccv_cnnp_model_batch_norm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_batch_norm_t));
1064 model_batch_norm->super.isa = &ccv_cnnp_batch_norm_isa;
1065 model_batch_norm->super.input_size = 1;
1066 model_batch_norm->super.outputs = &model_batch_norm->output;
1067 model_batch_norm->super.output_size = 1;
1068 model_batch_norm->super.is_trainable = is_trainable;
1069 ccv_cnnp_model_copy_name(&model_batch_norm->super, name);
1070 model_batch_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
1071 model_batch_norm->scale.graph = 0;
1072 model_batch_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1073 model_batch_norm->bias.graph = 0;
1074 model_batch_norm->params.bnorm.momentum = momentum;
1075 model_batch_norm->params.bnorm.epsilon = epsilon;
1076 return (ccv_cnnp_model_t*)model_batch_norm;
1077}
1078
1079static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
1080{
1081 const ccv_cnnp_model_batch_norm_t* const self = (const ccv_cnnp_model_batch_norm_t*)super;
1082 return ccv_cnnp_batch_norm(self->params.bnorm.momentum, self->params.bnorm.epsilon, self->super.is_trainable, self->super.name);
1083}
1084
1085// MARK - Convolution Layer
1086
1087typedef struct {
1088 ccv_cnnp_model_t super;
1089 ccv_nnc_tensor_symbol_t output;
1090 ccv_nnc_tensor_symbol_t weights;
1091 ccv_nnc_tensor_symbol_t bias;
1092 int groups;
1093 int filters;
1094 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1095 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1096 int no_bias;
1097 int format;
1098 ccv_nnc_hint_t hint;
1099} ccv_cnnp_model_convolution_t;
1100
1101static void _ccv_cnnp_convolution_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1102{
1103 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1104 PRINT(CCV_CLI_VERBOSE, "[cnnp_convolution_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_convolution_build] -\n"); fflush(stdout); } }
while (0);
1
Assuming the condition is false
→
2
←
Taking false branch
→
3
←
Loop condition is false. Exiting loop
→
1105 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1105, __extension__ __PRETTY_FUNCTION__); }));
4
←
Assuming 'input_size' is equal to 1
→
5
←
Taking true branch
→
1106 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1106, __extension__ __PRETTY_FUNCTION__
); }));
6
←
Assuming 'output_size' is equal to 1
→
7
←
Taking true branch
→
1107 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1108 int i;
1109 const int k_nd = ccv_nnc_tensor_nd(self->kdim);
1110 const int nd = k_nd + 2;
1111 ccv_nnc_tensor_param_t weights_params = params;
1112 if (self->format)
8
←
Assuming field 'format' is 0
→
9
←
Taking false branch
→
1113 weights_params.format = self->format;
1114 ccv_nnc_tensor_set_n(&weights_params, self->filters);
1115 const int a_nd = ccv_nnc_tensor_nd(params.dim);
1116 int c;
10
←
'c' declared without an initial value
→
1117 switch (params.format)
11
←
'Default' branch taken. Execution continues on line 1132
→
1118 {
1119 case CCV_TENSOR_FORMAT_NHWC:
1120 c = params.dim[a_nd - 1];
1121 break;
1122 case CCV_TENSOR_FORMAT_NCHW:
1123 if (a_nd == k_nd + 1)
1124 c = params.dim[0];
1125 else
1126 c = params.dim[a_nd <= 1 ? 0 : 1];
1127 break;
1128 case CCV_TENSOR_FORMAT_CHWN:
1129 c = params.dim[0];
1130 break;
1131 }
1132 assert(c % self->groups == 0)((void) sizeof ((c % self->groups == 0) ? 1 : 0), __extension__
({ if (c % self->groups == 0) ; else __assert_fail ("c % self->groups == 0"
, "ccv_cnnp_model_addons.c", 1132, __extension__ __PRETTY_FUNCTION__
); }));
12
←
The left operand of '%' is a garbage value
1133 ccv_nnc_tensor_set_c(&weights_params, nd, c / self->groups);
1134 int hw = -1;
1135 if (weights_params.format == CCV_TENSOR_FORMAT_NHWC || weights_params.format == CCV_TENSOR_FORMAT_CHWN)
1136 hw = 1;
1137 else if (weights_params.format == CCV_TENSOR_FORMAT_NCHW)
1138 hw = 2;
1139 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1139, __extension__ __PRETTY_FUNCTION__); }));
1140 for (i = 0; i < k_nd; i++)
1141 weights_params.dim[i + hw] = self->kdim[i];
1142 if (!self->weights.graph)
1143 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1144 assert(self->weights.graph == graph)((void) sizeof ((self->weights.graph == graph) ? 1 : 0), __extension__
({ if (self->weights.graph == graph) ; else __assert_fail
("self->weights.graph == graph", "ccv_cnnp_model_addons.c"
, 1144, __extension__ __PRETTY_FUNCTION__); }));
1145 ccv_nnc_tensor_param_t bias_params = params;
1146 if (self->format)
1147 bias_params.format = self->format;
1148 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1149 bias_params.dim[0] = self->filters;
1150 ccv_nnc_cmd_t cmd = CMD_CONVOLUTION_FORWARD(self->groups, self->filters)ccv_nnc_cmd(CCV_NNC_CONVOLUTION_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={}},.convolution={.count=self->filters,.groups
=self->groups}}), 0);
1151 for (i = 0; i < k_nd; i++)
1152 cmd.info.size.dim[i] = self->kdim[i];
1153 cmd.info.size.dim[k_nd] = c;
1154 memcpy(cmd.info.convolution.dilation, self->dilation, sizeof(self->dilation));
1155 ccv_nnc_tensor_param_t output_params;
1156 // Dilate weight size based on the dilation factor.
1157 for (i = 0; i < k_nd; i++)
1158 weights_params.dim[i + hw] = (self->kdim[i] - 1) * ccv_max(self->dilation[i], 1)({ typeof (self->dilation[i]) _a = (self->dilation[i]);
typeof (1) _b = (1); (_a > _b) ? _a : _b; }) + 1;
1159 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1160 params,
1161 weights_params,
1162 bias_params,
1163 }, 3, self->hint, &output_params, 1);
1164 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1165 ccv_nnc_graph_exec_symbol_t convolution;
1166 if (self->no_bias)
1167 convolution = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
}, (1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "convolution");
1168 else {
1169 if (!self->bias.graph)
1170 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1171 convolution = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
, self->bias}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "convolution");
1172 }
1173 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution, self->hint);
1174 outputs[0] = output;
1175}
1176
1177static void _ccv_cnnp_convolution_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
1178{
1179 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1180 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1181 const int n = ccv_max(ccv_nnc_tensor_get_n(weight_params), 1)({ typeof (ccv_nnc_tensor_get_n(weight_params)) _a = (ccv_nnc_tensor_get_n
(weight_params)); typeof (1) _b = (1); (_a > _b) ? _a : _b
; });
1182 const int count = ccv_nnc_tensor_count(weight_params);
1183 const float std = sqrtf(2) / sqrtf(count / n);
1184 const float bound = sqrtf(3) * std;
1185 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-bound, bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-bound, bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
1186 if (self->bias.graph)
1187 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
1188}
1189
1190static void _ccv_cnnp_convolution_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
1191{
1192 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1193 add_to_array(parameters, self->weights, is_trainable);
1194 if (self->bias.graph)
1195 add_to_array(parameters, self->bias, is_trainable);
1196}
1197
1198static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context);
1199
1200static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_isa = {
1201 .build = _ccv_cnnp_convolution_build,
1202 .init_states = _ccv_cnnp_convolution_init_states,
1203 .add_to_parameter = _ccv_cnnp_convolution_add_to_parameter,
1204 .copy = _ccv_cnnp_convolution_copy,
1205};
1206
1207ccv_cnnp_model_t* ccv_cnnp_convolution(const int groups, const int filters, const int kdim[CCV_NNC_MAX_DIM_ALLOC(12)], const int dilation[CCV_NNC_MAX_DIM_ALLOC(12)], const int no_bias, ccv_nnc_hint_t hint, const int format, const int is_trainable, const char* const name)
1208{
1209 ccv_cnnp_model_convolution_t* const model_convolution = (ccv_cnnp_model_convolution_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_convolution_t));
1210 model_convolution->super.isa = &ccv_cnnp_convolution_isa;
1211 model_convolution->super.input_size = 1;
1212 model_convolution->super.outputs = &model_convolution->output;
1213 model_convolution->super.output_size = 1;
1214 model_convolution->super.is_trainable = is_trainable;
1215 ccv_cnnp_model_copy_name(&model_convolution->super, name);
1216 model_convolution->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1217 model_convolution->weights.graph = 0;
1218 model_convolution->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1219 model_convolution->bias.graph = 0;
1220 model_convolution->groups = groups;
1221 model_convolution->filters = filters;
1222 memcpy(model_convolution->kdim, kdim, sizeof(model_convolution->kdim));
1223 memcpy(model_convolution->dilation, dilation, sizeof(model_convolution->dilation));
1224 model_convolution->no_bias = no_bias;
1225 model_convolution->hint = hint;
1226 model_convolution->format = format;
1227 return (ccv_cnnp_model_t*)model_convolution;
1228}
1229
1230static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context)
1231{
1232 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1233 return ccv_cnnp_convolution(self->groups, self->filters, self->kdim, self->dilation, self->no_bias, self->hint, self->format, self->super.is_trainable, self->super.name);
1234}
1235
1236// MARK - Convolution Transpose Layer
1237
1238typedef struct {
1239 ccv_cnnp_model_t super;
1240 ccv_nnc_tensor_symbol_t output;
1241 ccv_nnc_tensor_symbol_t weights;
1242 ccv_nnc_tensor_symbol_t bias;
1243 int groups;
1244 int filters;
1245 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1246 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1247 int output_padding;
1248 int no_bias;
1249 int format;
1250 ccv_nnc_hint_t hint;
1251} ccv_cnnp_model_convolution_transpose_t;
1252
1253static void _ccv_cnnp_convolution_transpose_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1254{
1255 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1256 PRINT(CCV_CLI_VERBOSE, "[cnnp_convolution_transpose_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_convolution_transpose_build] -\n"); fflush(stdout
); } } while (0);
1257 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1257, __extension__ __PRETTY_FUNCTION__); }));
1258 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1258, __extension__ __PRETTY_FUNCTION__
); }));
1259 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1260 int i;
1261 const int nd = CCV_NNC_MAX_DIM(2) + 2;
1262 ccv_nnc_tensor_param_t weights_params = params;
1263 if (self->format)
1264 weights_params.format = self->format;
1265 const int c = ccv_nnc_tensor_get_c(params);
1266 ccv_nnc_tensor_set_n(&weights_params, c);
1267 assert(c % self->groups == 0)((void) sizeof ((c % self->groups == 0) ? 1 : 0), __extension__
({ if (c % self->groups == 0) ; else __assert_fail ("c % self->groups == 0"
, "ccv_cnnp_model_addons.c", 1267, __extension__ __PRETTY_FUNCTION__
); }));
1268 ccv_nnc_tensor_set_c(&weights_params, nd, self->filters / self->groups);
1269 const int hw = ccv_nnc_tensor_hw(weights_params, nd, CCV_NNC_MAX_DIM(2));
1270 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1270, __extension__ __PRETTY_FUNCTION__); }));
1271 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1272 weights_params.dim[i + hw] = self->kdim[i];
1273 if (!self->weights.graph)
1274 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1275 assert(self->weights.graph == graph)((void) sizeof ((self->weights.graph == graph) ? 1 : 0), __extension__
({ if (self->weights.graph == graph) ; else __assert_fail
("self->weights.graph == graph", "ccv_cnnp_model_addons.c"
, 1275, __extension__ __PRETTY_FUNCTION__); }));
1276 ccv_nnc_tensor_param_t bias_params = params;
1277 if (self->format)
1278 bias_params.format = self->format;
1279 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1280 bias_params.dim[0] = self->filters;
1281 ccv_nnc_cmd_t cmd = CMD_CONVOLUTION_TRANSPOSE_FORWARD(self->groups, self->filters, self->output_padding)ccv_nnc_cmd(CCV_NNC_CONVOLUTION_TRANSPOSE_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={}},.convolution_transpose={.count=self->filters
,.groups=self->groups,.output_padding=self->output_padding
}}), 0);
1282 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1283 cmd.info.size.dim[i] = self->kdim[i];
1284 cmd.info.size.dim[CCV_NNC_MAX_DIM(2)] = c;
1285 memcpy(cmd.info.convolution_transpose.dilation, self->dilation, sizeof(self->dilation));
1286 ccv_nnc_tensor_param_t output_params;
1287 // Dilate weight size based on the dilation factor.
1288 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1289 weights_params.dim[i + hw] = (self->kdim[i] - 1) * ccv_max(self->dilation[i], 1)({ typeof (self->dilation[i]) _a = (self->dilation[i]);
typeof (1) _b = (1); (_a > _b) ? _a : _b; }) + 1;
1290 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1291 params,
1292 weights_params,
1293 bias_params,
1294 }, 3, self->hint, &output_params, 1);
1295 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1296 ccv_nnc_graph_exec_symbol_t convolution_transpose;
1297 if (self->no_bias)
1298 convolution_transpose = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
}, (1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "convolution_transpose");
1299 else {
1300 if (!self->bias.graph)
1301 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1302 convolution_transpose = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
, self->bias}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "convolution_transpose");
1303 }
1304 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution_transpose, self->hint);
1305 outputs[0] = output;
1306}
1307
1308static void _ccv_cnnp_convolution_transpose_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
1309{
1310 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1311 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1312 const int n = ccv_max(ccv_nnc_tensor_get_n(weight_params), 1)({ typeof (ccv_nnc_tensor_get_n(weight_params)) _a = (ccv_nnc_tensor_get_n
(weight_params)); typeof (1) _b = (1); (_a > _b) ? _a : _b
; });
1313 const int count = ccv_nnc_tensor_count(weight_params);
1314 const float std = sqrtf(2) / sqrtf(count / n);
1315 const float bound = sqrtf(3) * std;
1316 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-bound, bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-bound, bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
1317 if (self->bias.graph)
1318 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
1319}
1320
1321static void _ccv_cnnp_convolution_transpose_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
1322{
1323 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1324 add_to_array(parameters, self->weights, is_trainable);
1325 if (self->bias.graph)
1326 add_to_array(parameters, self->bias, is_trainable);
1327}
1328
1329static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
1330
1331static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_transpose_isa = {
1332 .build = _ccv_cnnp_convolution_transpose_build,
1333 .init_states = _ccv_cnnp_convolution_transpose_init_states,
1334 .add_to_parameter = _ccv_cnnp_convolution_transpose_add_to_parameter,
1335 .copy = _ccv_cnnp_convolution_transpose_copy,
1336};
1337
1338ccv_cnnp_model_t* ccv_cnnp_convolution_transpose(const int groups, const int filters, const int kdim[CCV_NNC_MAX_DIM_ALLOC(12)], const int dilation[CCV_NNC_MAX_DIM_ALLOC(12)], const int output_padding, const int no_bias, ccv_nnc_hint_t hint, const int format, const int is_trainable, const char* const name)
1339{
1340 ccv_cnnp_model_convolution_transpose_t* const model_convolution_transpose = (ccv_cnnp_model_convolution_transpose_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_convolution_transpose_t));
1341 model_convolution_transpose->super.isa = &ccv_cnnp_convolution_transpose_isa;
1342 model_convolution_transpose->super.input_size = 1;
1343 model_convolution_transpose->super.outputs = &model_convolution_transpose->output;
1344 model_convolution_transpose->super.output_size = 1;
1345 model_convolution_transpose->super.is_trainable = is_trainable;
1346 ccv_cnnp_model_copy_name(&model_convolution_transpose->super, name);
1347 model_convolution_transpose->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1348 model_convolution_transpose->weights.graph = 0;
1349 model_convolution_transpose->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1350 model_convolution_transpose->bias.graph = 0;
1351 model_convolution_transpose->groups = groups;
1352 model_convolution_transpose->filters = filters;
1353 memcpy(model_convolution_transpose->kdim, kdim, sizeof(model_convolution_transpose->kdim));
1354 memcpy(model_convolution_transpose->dilation, dilation, sizeof(model_convolution_transpose->dilation));
1355 model_convolution_transpose->output_padding = output_padding;
1356 model_convolution_transpose->no_bias = no_bias;
1357 model_convolution_transpose->hint = hint;
1358 model_convolution_transpose->format = format;
1359 return (ccv_cnnp_model_t*)model_convolution_transpose;
1360}
1361
1362static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
1363{
1364 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1365 return ccv_cnnp_convolution_transpose(self->groups, self->filters, self->kdim, self->dilation, self->output_padding, self->no_bias, self->hint, self->format, self->super.is_trainable, self->super.name);
1366}
1367
1368// MARK - Dense Layer
1369
1370typedef struct {
1371 ccv_cnnp_model_t super;
1372 ccv_nnc_tensor_symbol_t output;
1373 ccv_nnc_tensor_symbol_t weights;
1374 ccv_nnc_tensor_symbol_t bias;
1375 int count;
1376 int no_bias;
1377 int flags;
1378} ccv_cnnp_model_dense_t;
1379
1380static void _ccv_cnnp_dense_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1381{
1382 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1383 PRINT(CCV_CLI_VERBOSE, "[cnnp_dense_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_dense_build] -\n"); fflush(stdout); } } while
(0);
1384 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1384, __extension__ __PRETTY_FUNCTION__); }));
1385 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1385, __extension__ __PRETTY_FUNCTION__
); }));
1386 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1387 ccv_nnc_tensor_param_t weights_params = params;
1388 memset(weights_params.dim, 0, sizeof(weights_params.dim));
1389 weights_params.dim[0] = self->count;
1390 weights_params.dim[1] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
1391 if (!self->weights.graph)
1392 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1393 assert(self->weights.graph == graph)((void) sizeof ((self->weights.graph == graph) ? 1 : 0), __extension__
({ if (self->weights.graph == graph) ; else __assert_fail
("self->weights.graph == graph", "ccv_cnnp_model_addons.c"
, 1393, __extension__ __PRETTY_FUNCTION__); }));
1394 ccv_nnc_tensor_param_t bias_params = params;
1395 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1396 bias_params.dim[0] = self->count;
1397 ccv_nnc_cmd_t cmd = {0};
1398 cmd.cmd = CCV_NNC_GEMM_FORWARD;
1399 cmd.info.blas.a[0] = 1;
1400 cmd.info.blas.a[1] = 1;
1401 cmd.info.blas.transpose_b[0] = 0;
1402 cmd.info.blas.transpose_b[1] = 1;
1403 cmd.info.blas.flags = self->flags;
1404 ccv_nnc_tensor_param_t output_params;
1405 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1406 params,
1407 weights_params,
1408 bias_params,
1409 }, 3, ccv_nnc_no_hint, &output_params, 1);
1410 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1411 if (self->no_bias)
1412 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
}, (1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "dense");
1413 else {
1414 if (!self->bias.graph)
1415 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1416 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], self->weights, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->weights
, self->bias}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "dense");
1417 }
1418 outputs[0] = output;
1419}
1420
1421static void _ccv_cnnp_dense_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
1422{
1423 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1424 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1425 const int c = weight_params.dim[1];
1426 const float std = sqrtf(2) / sqrtf(c);
1427 const float bound = sqrtf(3) * std;
1428 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-bound, bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-bound, bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
1429 if (self->bias.graph)
1430 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
1431}
1432
1433static void _ccv_cnnp_dense_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
1434{
1435 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1436 add_to_array(parameters, self->weights, is_trainable);
1437 if (self->bias.graph)
1438 add_to_array(parameters, self->bias, is_trainable);
1439}
1440
1441static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
1442
1443static const ccv_cnnp_model_vtab_t ccv_cnnp_dense_isa = {
1444 .build = _ccv_cnnp_dense_build,
1445 .init_states = _ccv_cnnp_dense_init_states,
1446 .add_to_parameter = _ccv_cnnp_dense_add_to_parameter,
1447 .copy = _ccv_cnnp_dense_copy,
1448};
1449
1450ccv_cnnp_model_t* ccv_cnnp_dense(const int count, const int no_bias, const int flags, const int is_trainable, const char* const name)
1451{
1452 ccv_cnnp_model_dense_t* const model_dense = (ccv_cnnp_model_dense_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dense_t));
1453 model_dense->super.isa = &ccv_cnnp_dense_isa;
1454 model_dense->super.input_size = 1;
1455 model_dense->super.outputs = &model_dense->output;
1456 model_dense->super.output_size = 1;
1457 model_dense->super.is_trainable = is_trainable;
1458 ccv_cnnp_model_copy_name(&model_dense->super, name);
1459 model_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1460 model_dense->weights.graph = 0;
1461 model_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1462 model_dense->bias.graph = 0;
1463 model_dense->count = count;
1464 model_dense->no_bias = no_bias;
1465 model_dense->flags = flags;
1466 return (ccv_cnnp_model_t*)model_dense;
1467}
1468
1469static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
1470{
1471 const ccv_cnnp_model_dense_t* const self = (const ccv_cnnp_model_dense_t*)super;
1472 return ccv_cnnp_dense(self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
1473}
1474
1475// MARK - Pool Layers
1476
1477typedef struct {
1478 ccv_cnnp_model_t super;
1479 ccv_nnc_tensor_symbol_t output;
1480 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1481 ccv_nnc_hint_t hint;
1482} ccv_cnnp_model_pool_t;
1483
1484static void _ccv_cnnp_max_pool_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1485{
1486 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1487 PRINT(CCV_CLI_VERBOSE, "[cnnp_max_pool_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_max_pool_build] -\n"); fflush(stdout); } } while
(0);
1488 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1488, __extension__ __PRETTY_FUNCTION__); }));
1489 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1489, __extension__ __PRETTY_FUNCTION__
); }));
1490 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1491 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1492 ccv_nnc_cmd_t cmd;
1493 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1494 cmd = CMD_MAX_POOL_FORWARD(params.dim[hw], params.dim[hw + 1])ccv_nnc_cmd(CCV_NNC_MAX_POOL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={params.dim[hw], params.dim[hw + 1],1}}}), 0);
1495 else
1496 cmd = CMD_MAX_POOL_FORWARD(self->kdim[0], self->kdim[1])ccv_nnc_cmd(CCV_NNC_MAX_POOL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={self->kdim[0], self->kdim[1],1}}}), 0);
1497 ccv_nnc_tensor_param_t output_params;
1498 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1499 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1500 const ccv_nnc_graph_exec_symbol_t exec = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(pool_output)(const ccv_nnc_tensor_symbol_t []){pool_output}, (1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "max_pool");
1501 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1502 outputs[0] = pool_output;
1503}
1504
1505static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1506
1507static const ccv_cnnp_model_vtab_t ccv_cnnp_max_pool_isa = {
1508 .build = _ccv_cnnp_max_pool_build,
1509 .copy = _ccv_cnnp_max_pool_copy,
1510};
1511
1512ccv_cnnp_model_t* ccv_cnnp_max_pool(const int kdim[CCV_NNC_MAX_DIM_ALLOC(12)], const ccv_nnc_hint_t hint, const char* const name)
1513{
1514 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1515 model_pool->super.isa = &ccv_cnnp_max_pool_isa;
1516 model_pool->super.input_size = 1;
1517 model_pool->super.outputs = &model_pool->output;
1518 model_pool->super.output_size = 1;
1519 ccv_cnnp_model_copy_name(&model_pool->super, name);
1520 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1521 model_pool->hint = hint;
1522 return (ccv_cnnp_model_t*)model_pool;
1523}
1524
1525static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1526{
1527 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1528 return ccv_cnnp_max_pool(self->kdim, self->hint, self->super.name);
1529}
1530
1531static void _ccv_cnnp_average_pool_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1532{
1533 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1534 PRINT(CCV_CLI_VERBOSE, "[cnnp_average_pool_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_average_pool_build] -\n"); fflush(stdout); }
} while (0);
1535 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1535, __extension__ __PRETTY_FUNCTION__); }));
1536 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1536, __extension__ __PRETTY_FUNCTION__
); }));
1537 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1538 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1539 ccv_nnc_cmd_t cmd;
1540 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1541 cmd = CMD_AVERAGE_POOL_FORWARD(params.dim[hw], params.dim[hw + 1])ccv_nnc_cmd(CCV_NNC_AVERAGE_POOL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={params.dim[hw], params.dim[hw + 1],1}}}), 0);
1542 else
1543 cmd = CMD_AVERAGE_POOL_FORWARD(self->kdim[0], self->kdim[1])ccv_nnc_cmd(CCV_NNC_AVERAGE_POOL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={self->kdim[0], self->kdim[1],1}}}), 0);
1544 ccv_nnc_tensor_param_t output_params;
1545 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1546 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1547 const ccv_nnc_graph_exec_symbol_t exec = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(pool_output)(const ccv_nnc_tensor_symbol_t []){pool_output}, (1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "average_pool");
1548 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1549 outputs[0] = pool_output;
1550}
1551
1552static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1553
1554static const ccv_cnnp_model_vtab_t ccv_cnnp_average_pool_isa = {
1555 .build = _ccv_cnnp_average_pool_build,
1556 .copy = _ccv_cnnp_average_pool_copy,
1557};
1558
1559ccv_cnnp_model_t* ccv_cnnp_average_pool(const int kdim[CCV_NNC_MAX_DIM_ALLOC(12)], const ccv_nnc_hint_t hint, const char* const name)
1560{
1561 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1562 model_pool->super.isa = &ccv_cnnp_average_pool_isa;
1563 model_pool->super.input_size = 1;
1564 model_pool->super.outputs = &model_pool->output;
1565 model_pool->super.output_size = 1;
1566 ccv_cnnp_model_copy_name(&model_pool->super, name);
1567 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1568 model_pool->hint = hint;
1569 return (ccv_cnnp_model_t*)model_pool;
1570}
1571
1572static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1573{
1574 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1575 return ccv_cnnp_average_pool(self->kdim, self->hint, self->super.name);
1576}
1577
1578// MARK - RELU Layer
1579
1580typedef struct {
1581 ccv_cnnp_model_t super;
1582 ccv_nnc_tensor_symbol_t output;
1583} ccv_cnnp_model_relu_t;
1584
1585static void _ccv_cnnp_relu_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1586{
1587 PRINT(CCV_CLI_VERBOSE, "[cnnp_relu_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_relu_build] -\n"); fflush(stdout); } } while
(0);
1588 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1588, __extension__ __PRETTY_FUNCTION__); }));
1589 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1589, __extension__ __PRETTY_FUNCTION__
); }));
1590 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1591 ccv_nnc_tensor_param_t output_params;
1592 const ccv_nnc_cmd_t relu = CMD_RELU_FORWARD()ccv_nnc_cmd(CCV_NNC_RELU_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1593 ccv_nnc_hint_tensor_auto(relu, (ccv_nnc_tensor_param_t []){
1594 params,
1595 }, 1, ccv_nnc_no_hint, &output_params, 1);
1596 const ccv_nnc_tensor_symbol_t relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1597 ccv_nnc_graph_exec_symbol_new(graph, relu, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(relu_output)(const ccv_nnc_tensor_symbol_t []){relu_output}, (1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "relu");
1598 outputs[0] = relu_output;
1599}
1600
1601static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1602
1603static const ccv_cnnp_model_vtab_t ccv_cnnp_relu_isa = {
1604 .build = _ccv_cnnp_relu_build,
1605 .copy = _ccv_cnnp_relu_copy,
1606};
1607
1608ccv_cnnp_model_t* ccv_cnnp_relu(const char* const name)
1609{
1610 ccv_cnnp_model_relu_t* const model_relu = (ccv_cnnp_model_relu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_relu_t));
1611 model_relu->super.isa = &ccv_cnnp_relu_isa;
1612 model_relu->super.input_size = 1;
1613 model_relu->super.outputs = &model_relu->output;
1614 model_relu->super.output_size = 1;
1615 ccv_cnnp_model_copy_name(&model_relu->super, name);
1616 return (ccv_cnnp_model_t*)model_relu;
1617}
1618
1619static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context)
1620{
1621 return ccv_cnnp_relu(self->name);
1622}
1623
1624// MARK - Sigmoid Layer
1625
1626typedef struct {
1627 ccv_cnnp_model_t super;
1628 ccv_nnc_tensor_symbol_t output;
1629} ccv_cnnp_model_sigmoid_t;
1630
1631static void _ccv_cnnp_sigmoid_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1632{
1633 PRINT(CCV_CLI_VERBOSE, "[cnnp_sigmoid_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sigmoid_build] -\n"); fflush(stdout); } } while
(0);
1634 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1634, __extension__ __PRETTY_FUNCTION__); }));
1635 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1635, __extension__ __PRETTY_FUNCTION__
); }));
1636 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1637 ccv_nnc_tensor_param_t output_params;
1638 const ccv_nnc_cmd_t sigmoid = CMD_SIGMOID_FORWARD()ccv_nnc_cmd(CCV_NNC_SIGMOID_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1639 ccv_nnc_hint_tensor_auto(sigmoid, (ccv_nnc_tensor_param_t []){
1640 params,
1641 }, 1, ccv_nnc_no_hint, &output_params, 1);
1642 const ccv_nnc_tensor_symbol_t sigmoid_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1643 ccv_nnc_graph_exec_symbol_new(graph, sigmoid, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(sigmoid_output)(const ccv_nnc_tensor_symbol_t []){sigmoid_output}, (1 +1 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1
), "sigmoid");
1644 outputs[0] = sigmoid_output;
1645}
1646
1647static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context);
1648
1649static const ccv_cnnp_model_vtab_t ccv_cnnp_sigmoid_isa = {
1650 .build = _ccv_cnnp_sigmoid_build,
1651 .copy = _ccv_cnnp_sigmoid_copy,
1652};
1653
1654ccv_cnnp_model_t* ccv_cnnp_sigmoid(const char* const name)
1655{
1656 ccv_cnnp_model_sigmoid_t* const model_sigmoid = (ccv_cnnp_model_sigmoid_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sigmoid_t));
1657 model_sigmoid->super.isa = &ccv_cnnp_sigmoid_isa;
1658 model_sigmoid->super.input_size = 1;
1659 model_sigmoid->super.outputs = &model_sigmoid->output;
1660 model_sigmoid->super.output_size = 1;
1661 ccv_cnnp_model_copy_name(&model_sigmoid->super, name);
1662 return (ccv_cnnp_model_t*)model_sigmoid;
1663}
1664
1665static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context)
1666{
1667 return ccv_cnnp_sigmoid(self->name);
1668}
1669
1670// MARK - Tanh Layer
1671
1672typedef struct {
1673 ccv_cnnp_model_t super;
1674 ccv_nnc_tensor_symbol_t output;
1675} ccv_cnnp_model_tanh_t;
1676
1677static void _ccv_cnnp_tanh_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1678{
1679 PRINT(CCV_CLI_VERBOSE, "[cnnp_tanh_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_tanh_build] -\n"); fflush(stdout); } } while
(0);
1680 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1680, __extension__ __PRETTY_FUNCTION__); }));
1681 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1681, __extension__ __PRETTY_FUNCTION__
); }));
1682 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1683 ccv_nnc_tensor_param_t output_params;
1684 const ccv_nnc_cmd_t tanh = CMD_TANH_FORWARD()ccv_nnc_cmd(CCV_NNC_TANH_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1685 ccv_nnc_hint_tensor_auto(tanh, (ccv_nnc_tensor_param_t []){
1686 params,
1687 }, 1, ccv_nnc_no_hint, &output_params, 1);
1688 const ccv_nnc_tensor_symbol_t tanh_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1689 ccv_nnc_graph_exec_symbol_new(graph, tanh, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(tanh_output)(const ccv_nnc_tensor_symbol_t []){tanh_output}, (1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "tanh");
1690 outputs[0] = tanh_output;
1691}
1692
1693static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context);
1694
1695static const ccv_cnnp_model_vtab_t ccv_cnnp_tanh_isa = {
1696 .build = _ccv_cnnp_tanh_build,
1697 .copy = _ccv_cnnp_tanh_copy,
1698};
1699
1700ccv_cnnp_model_t* ccv_cnnp_tanh(const char* const name)
1701{
1702 ccv_cnnp_model_tanh_t* const model_tanh = (ccv_cnnp_model_tanh_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_tanh_t));
1703 model_tanh->super.isa = &ccv_cnnp_tanh_isa;
1704 model_tanh->super.input_size = 1;
1705 model_tanh->super.outputs = &model_tanh->output;
1706 model_tanh->super.output_size = 1;
1707 ccv_cnnp_model_copy_name(&model_tanh->super, name);
1708 return (ccv_cnnp_model_t*)model_tanh;
1709}
1710
1711static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context)
1712{
1713 return ccv_cnnp_tanh(self->name);
1714}
1715
1716// MARK - Swish Layer
1717
1718typedef struct {
1719 ccv_cnnp_model_t super;
1720 ccv_nnc_tensor_symbol_t output;
1721} ccv_cnnp_model_swish_t;
1722
1723static void _ccv_cnnp_swish_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1724{
1725 PRINT(CCV_CLI_VERBOSE, "[cnnp_swish_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_swish_build] -\n"); fflush(stdout); } } while
(0);
1726 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1726, __extension__ __PRETTY_FUNCTION__); }));
1727 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1727, __extension__ __PRETTY_FUNCTION__
); }));
1728 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1729 ccv_nnc_tensor_param_t output_params;
1730 const ccv_nnc_cmd_t swish = CMD_SWISH_FORWARD()ccv_nnc_cmd(CCV_NNC_SWISH_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1731 ccv_nnc_hint_tensor_auto(swish, (ccv_nnc_tensor_param_t []){
1732 params,
1733 }, 1, ccv_nnc_no_hint, &output_params, 1);
1734 const ccv_nnc_tensor_symbol_t swish_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1735 ccv_nnc_graph_exec_symbol_new(graph, swish, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(swish_output)(const ccv_nnc_tensor_symbol_t []){swish_output}, (1 +1 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "swish");
1736 outputs[0] = swish_output;
1737}
1738
1739static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context);
1740
1741static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_isa = {
1742 .build = _ccv_cnnp_swish_build,
1743 .copy = _ccv_cnnp_swish_copy,
1744};
1745
1746ccv_cnnp_model_t* ccv_cnnp_swish(const char* const name)
1747{
1748 ccv_cnnp_model_swish_t* const model_swish = (ccv_cnnp_model_swish_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swish_t));
1749 model_swish->super.isa = &ccv_cnnp_swish_isa;
1750 model_swish->super.input_size = 1;
1751 model_swish->super.outputs = &model_swish->output;
1752 model_swish->super.output_size = 1;
1753 ccv_cnnp_model_copy_name(&model_swish->super, name);
1754 return (ccv_cnnp_model_t*)model_swish;
1755}
1756
1757static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context)
1758{
1759 return ccv_cnnp_swish(self->name);
1760}
1761
1762// MARK - GELU Layer
1763
1764typedef struct {
1765 ccv_cnnp_model_t super;
1766 ccv_nnc_tensor_symbol_t output;
1767 int tanh;
1768} ccv_cnnp_model_gelu_t;
1769
1770static void _ccv_cnnp_gelu_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1771{
1772 PRINT(CCV_CLI_VERBOSE, "[cnnp_gelu_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_gelu_build] -\n"); fflush(stdout); } } while
(0);
1773 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1773, __extension__ __PRETTY_FUNCTION__); }));
1774 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1774, __extension__ __PRETTY_FUNCTION__
); }));
1775 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1776 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1777 ccv_nnc_tensor_param_t output_params;
1778 const ccv_nnc_cmd_t gelu = CMD_GELU_FORWARD(self->tanh)ccv_nnc_cmd(CCV_NNC_GELU_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.gelu={.tanh=self->tanh}}, 0);
1779 ccv_nnc_hint_tensor_auto(gelu, (ccv_nnc_tensor_param_t []){
1780 params,
1781 }, 1, ccv_nnc_no_hint, &output_params, 1);
1782 const ccv_nnc_tensor_symbol_t gelu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1783 ccv_nnc_graph_exec_symbol_new(graph, gelu, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(gelu_output)(const ccv_nnc_tensor_symbol_t []){gelu_output}, (1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "gelu");
1784 outputs[0] = gelu_output;
1785}
1786
1787static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const self, void* const context);
1788
1789static const ccv_cnnp_model_vtab_t ccv_cnnp_gelu_isa = {
1790 .build = _ccv_cnnp_gelu_build,
1791 .copy = _ccv_cnnp_gelu_copy,
1792};
1793
1794ccv_cnnp_model_t* ccv_cnnp_gelu(const int tanh, const char* const name)
1795{
1796 ccv_cnnp_model_gelu_t* const model_gelu = (ccv_cnnp_model_gelu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gelu_t));
1797 model_gelu->super.isa = &ccv_cnnp_gelu_isa;
1798 model_gelu->super.input_size = 1;
1799 model_gelu->super.outputs = &model_gelu->output;
1800 model_gelu->super.output_size = 1;
1801 model_gelu->tanh = tanh;
1802 ccv_cnnp_model_copy_name(&model_gelu->super, name);
1803 return (ccv_cnnp_model_t*)model_gelu;
1804}
1805
1806static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const super, void* const context)
1807{
1808 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1809 return ccv_cnnp_gelu(self->tanh, self->super.name);
1810}
1811
1812// MARK - Leaky ReLU Layer
1813
1814typedef struct {
1815 ccv_cnnp_model_t super;
1816 ccv_nnc_tensor_symbol_t output;
1817 float negative_slope;
1818} ccv_cnnp_model_leaky_relu_t;
1819
1820static void _ccv_cnnp_leaky_relu_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1821{
1822 PRINT(CCV_CLI_VERBOSE, "[cnnp_leaky_relu_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_leaky_relu_build] -\n"); fflush(stdout); } }
while (0);
1823 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1823, __extension__ __PRETTY_FUNCTION__); }));
1824 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1824, __extension__ __PRETTY_FUNCTION__
); }));
1825 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
1826 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1827 ccv_nnc_tensor_param_t output_params;
1828 const ccv_nnc_cmd_t leaky_relu = CMD_LEAKY_RELU_FORWARD(self->negative_slope)ccv_nnc_cmd(CCV_NNC_LEAKY_RELU_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.leaky_relu={.negative_slope=self->
negative_slope}}, 0);
1829 ccv_nnc_hint_tensor_auto(leaky_relu, (ccv_nnc_tensor_param_t []){
1830 params,
1831 }, 1, ccv_nnc_no_hint, &output_params, 1);
1832 const ccv_nnc_tensor_symbol_t leaky_relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1833 ccv_nnc_graph_exec_symbol_new(graph, leaky_relu, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(leaky_relu_output)(const ccv_nnc_tensor_symbol_t []){leaky_relu_output}, (1 +1 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
-1), "leaky_relu");
1834 outputs[0] = leaky_relu_output;
1835}
1836
1837static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1838
1839static const ccv_cnnp_model_vtab_t ccv_cnnp_leaky_relu_isa = {
1840 .build = _ccv_cnnp_leaky_relu_build,
1841 .copy = _ccv_cnnp_leaky_relu_copy,
1842};
1843
1844ccv_cnnp_model_t* ccv_cnnp_leaky_relu(const float negative_slope, const char* const name)
1845{
1846 ccv_cnnp_model_leaky_relu_t* const model_leaky_relu = (ccv_cnnp_model_leaky_relu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_leaky_relu_t));
1847 model_leaky_relu->super.isa = &ccv_cnnp_leaky_relu_isa;
1848 model_leaky_relu->super.input_size = 1;
1849 model_leaky_relu->super.outputs = &model_leaky_relu->output;
1850 model_leaky_relu->super.output_size = 1;
1851 model_leaky_relu->negative_slope = negative_slope;
1852 ccv_cnnp_model_copy_name(&model_leaky_relu->super, name);
1853 return (ccv_cnnp_model_t*)model_leaky_relu;
1854}
1855
1856static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const super, void* const context)
1857{
1858 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
1859 return ccv_cnnp_leaky_relu(self->negative_slope, self->super.name);
1860}
1861
1862// MARK - Softmax Layer
1863
1864typedef struct {
1865 ccv_cnnp_model_t super;
1866 ccv_nnc_tensor_symbol_t output;
1867} ccv_cnnp_model_softmax_t;
1868
1869static void _ccv_cnnp_softmax_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1870{
1871 PRINT(CCV_CLI_VERBOSE, "[cnnp_softmax_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_softmax_build] -\n"); fflush(stdout); } } while
(0);
1872 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 1872, __extension__ __PRETTY_FUNCTION__); }));
1873 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1873, __extension__ __PRETTY_FUNCTION__
); }));
1874 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1875 ccv_nnc_tensor_param_t output_params;
1876 const ccv_nnc_cmd_t softmax = CMD_SOFTMAX_FORWARD()ccv_nnc_cmd(CCV_NNC_SOFTMAX_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1877 ccv_nnc_hint_tensor_auto(softmax, (ccv_nnc_tensor_param_t []){
1878 params,
1879 }, 1, ccv_nnc_no_hint, &output_params, 1);
1880 const ccv_nnc_tensor_symbol_t softmax_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1881 ccv_nnc_graph_exec_symbol_new(graph, softmax, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(softmax_output)(const ccv_nnc_tensor_symbol_t []){softmax_output}, (1 +1 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1
), "softmax");
1882 outputs[0] = softmax_output;
1883}
1884
1885static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context);
1886
1887static const ccv_cnnp_model_vtab_t ccv_cnnp_softmax_isa = {
1888 .build = _ccv_cnnp_softmax_build,
1889 .copy = _ccv_cnnp_softmax_copy,
1890};
1891
1892ccv_cnnp_model_t* ccv_cnnp_softmax(const char* const name)
1893{
1894 ccv_cnnp_model_softmax_t* const model_softmax = (ccv_cnnp_model_softmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softmax_t));
1895 model_softmax->super.isa = &ccv_cnnp_softmax_isa;
1896 model_softmax->super.input_size = 1;
1897 model_softmax->super.outputs = &model_softmax->output;
1898 model_softmax->super.output_size = 1;
1899 ccv_cnnp_model_copy_name(&model_softmax->super, name);
1900 return (ccv_cnnp_model_t*)model_softmax;
1901}
1902
1903static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context)
1904{
1905 return ccv_cnnp_softmax(self->name);
1906}
1907
1908// MARK - Add Layer
1909
1910typedef struct {
1911 ccv_cnnp_model_t super;
1912 float p;
1913 float q;
1914 ccv_nnc_tensor_symbol_t output;
1915} ccv_cnnp_model_add_t;
1916
1917static void _ccv_cnnp_add_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1918{
1919 PRINT(CCV_CLI_VERBOSE, "[cnnp_add_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_add_build] -\n"); fflush(stdout); } } while (
0);
1920 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
1921 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 1921, __extension__ __PRETTY_FUNCTION__); }));
1922 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1922, __extension__ __PRETTY_FUNCTION__
); }));
1923 ccv_nnc_tensor_param_t input_params[2];
1924 int i;
1925 for (i = 0; i < 2; i++)
1926 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1927 ccv_nnc_tensor_param_t output_params;
1928 const ccv_nnc_cmd_t add = CMD_ADD_FORWARD(self->p, self->q)ccv_nnc_cmd(CCV_NNC_ADD_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={self->p, self->q}}}, 0);
1929 ccv_nnc_hint_tensor_auto(add, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1930 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1931 ccv_nnc_graph_exec_symbol_new(graph, add, inputs, input_size, outputs, output_size, "add");
1932}
1933
1934static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const self, void* const context);
1935
1936static const ccv_cnnp_model_vtab_t ccv_cnnp_add_isa = {
1937 .build = _ccv_cnnp_add_build,
1938 .copy = _ccv_cnnp_add_copy,
1939};
1940
1941ccv_cnnp_model_t* ccv_cnnp_add(const float p, const float q, const char* const name)
1942{
1943 ccv_cnnp_model_add_t* const model_add = (ccv_cnnp_model_add_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_add_t));
1944 model_add->super.isa = &ccv_cnnp_add_isa;
1945 model_add->super.input_size = 2;
1946 model_add->super.outputs = &model_add->output;
1947 model_add->super.output_size = 1;
1948 model_add->p = p;
1949 model_add->q = q;
1950 ccv_cnnp_model_copy_name(&model_add->super, name);
1951 return (ccv_cnnp_model_t*)model_add;
1952}
1953
1954static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const super, void* const context)
1955{
1956 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
1957 return ccv_cnnp_add(self->p, self->q, self->super.name);
1958}
1959
1960// MARK - Mul Layer
1961
1962typedef struct {
1963 ccv_cnnp_model_t super;
1964 ccv_nnc_tensor_symbol_t output;
1965 float p;
1966} ccv_cnnp_model_mul_t;
1967
1968static void _ccv_cnnp_mul_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
1969{
1970 PRINT(CCV_CLI_VERBOSE, "[cnnp_mul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_mul_build] -\n"); fflush(stdout); } } while (
0);
1971 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
1972 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 1972, __extension__ __PRETTY_FUNCTION__); }));
1973 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 1973, __extension__ __PRETTY_FUNCTION__
); }));
1974 ccv_nnc_tensor_param_t input_params[2];
1975 int i;
1976 for (i = 0; i < 2; i++)
1977 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1978 ccv_nnc_tensor_param_t output_params;
1979 const ccv_nnc_cmd_t mul = CMD_MUL_FORWARD(self->p)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={self->p,}}}, 0);
1980 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1981 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1982 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "mul");
1983}
1984
1985static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
1986
1987static const ccv_cnnp_model_vtab_t ccv_cnnp_mul_isa = {
1988 .build = _ccv_cnnp_mul_build,
1989 .copy = _ccv_cnnp_mul_copy,
1990};
1991
1992ccv_cnnp_model_t* ccv_cnnp_mul(const float p, const char* const name)
1993{
1994 ccv_cnnp_model_mul_t* const model_mul = (ccv_cnnp_model_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_mul_t));
1995 model_mul->super.isa = &ccv_cnnp_mul_isa;
1996 model_mul->super.input_size = 2;
1997 model_mul->super.outputs = &model_mul->output;
1998 model_mul->super.output_size = 1;
1999 model_mul->p = p;
2000 ccv_cnnp_model_copy_name(&model_mul->super, name);
2001 return (ccv_cnnp_model_t*)model_mul;
2002}
2003
2004static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2005{
2006 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2007 return ccv_cnnp_mul(self->p, self->super.name);
2008}
2009
2010// MARK - Scalar Mul Layer
2011
2012typedef struct {
2013 ccv_cnnp_model_t super;
2014 ccv_nnc_tensor_symbol_t output;
2015 float a;
2016} ccv_cnnp_model_scalar_mul_t;
2017
2018static void _ccv_cnnp_scalar_mul_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2019{
2020 PRINT(CCV_CLI_VERBOSE, "[cnnp_scalar_mul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_scalar_mul_build] -\n"); fflush(stdout); } }
while (0);
2021 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2021, __extension__ __PRETTY_FUNCTION__); }));
2022 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2022, __extension__ __PRETTY_FUNCTION__
); }));
2023 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2024 ccv_nnc_tensor_param_t output_params;
2025 ccv_cnnp_model_scalar_mul_t* const self = (ccv_cnnp_model_scalar_mul_t*)super;
2026 const ccv_nnc_cmd_t scalar_mul = CMD_SCALAR_MUL_FORWARD(self->a)ccv_nnc_cmd(CCV_NNC_SCALAR_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={self->a,}}}, 0);
2027 ccv_nnc_hint_tensor_auto(scalar_mul, (ccv_nnc_tensor_param_t []){
2028 params,
2029 }, 1, ccv_nnc_no_hint, &output_params, 1);
2030 const ccv_nnc_tensor_symbol_t scalar_mul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2031 ccv_nnc_graph_exec_symbol_new(graph, scalar_mul, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(scalar_mul_output)(const ccv_nnc_tensor_symbol_t []){scalar_mul_output}, (1 +1 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
-1), "scalar_mul");
2032 outputs[0] = scalar_mul_output;
2033}
2034
2035static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context);
2036
2037static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_mul_isa = {
2038 .build = _ccv_cnnp_scalar_mul_build,
2039 .copy = _ccv_cnnp_scalar_mul_copy,
2040};
2041
2042ccv_cnnp_model_t* ccv_cnnp_scalar_mul(const float a, const char* const name)
2043{
2044 ccv_cnnp_model_scalar_mul_t* const model_scalar_mul = (ccv_cnnp_model_scalar_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scalar_mul_t));
2045 model_scalar_mul->super.isa = &ccv_cnnp_scalar_mul_isa;
2046 model_scalar_mul->super.input_size = 1;
2047 model_scalar_mul->super.outputs = &model_scalar_mul->output;
2048 model_scalar_mul->super.output_size = 1;
2049 model_scalar_mul->a = a;
2050 ccv_cnnp_model_copy_name(&model_scalar_mul->super, name);
2051 return (ccv_cnnp_model_t*)model_scalar_mul;
2052}
2053
2054static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2055{
2056 const ccv_cnnp_model_scalar_mul_t* const self = (const ccv_cnnp_model_scalar_mul_t*)super;
2057 return ccv_cnnp_scalar_mul(self->a, self->super.name);
2058}
2059
2060// MARK - Div Layer
2061
2062typedef struct {
2063 ccv_cnnp_model_t super;
2064 ccv_nnc_tensor_symbol_t output;
2065 int reciprocal;
2066} ccv_cnnp_model_div_t;
2067
2068static void _ccv_cnnp_div_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2069{
2070 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2071 PRINT(CCV_CLI_VERBOSE, "[cnnp_div_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_div_build] -\n"); fflush(stdout); } } while (
0);
2072 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2072, __extension__ __PRETTY_FUNCTION__
); }));
2073 ccv_nnc_tensor_param_t input_params[2];
2074 int i;
2075 ccv_nnc_tensor_param_t output_params;
2076 const ccv_nnc_cmd_t div = CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2077 if (self->reciprocal)
2078 {
2079 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2079, __extension__ __PRETTY_FUNCTION__); }));
2080 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2081 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2082 ccv_nnc_hint_tensor_auto(div, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2083 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2084 ccv_nnc_graph_exec_symbol_new(graph, div, TENSOR_SYMBOL_LIST(NO_TENSOR_SYMBOL, inputs[0])(const ccv_nnc_tensor_symbol_t []){(const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, inputs[0]}, (1 +1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), outputs, output_size, "div");
2085 } else {
2086 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2086, __extension__ __PRETTY_FUNCTION__); }));
2087 for (i = 0; i < 2; i++)
2088 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2089 ccv_nnc_hint_tensor_auto(div, input_params, input_size, ccv_nnc_no_hint, &output_params, 1);
2090 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2091 ccv_nnc_graph_exec_symbol_new(graph, div, inputs, input_size, outputs, output_size, "div");
2092 }
2093}
2094
2095static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const self, void* const context);
2096
2097static const ccv_cnnp_model_vtab_t ccv_cnnp_div_isa = {
2098 .build = _ccv_cnnp_div_build,
2099 .copy = _ccv_cnnp_div_copy,
2100};
2101
2102ccv_cnnp_model_t* ccv_cnnp_div(const int reciprocal, const char* const name)
2103{
2104 ccv_cnnp_model_div_t* const model_div = (ccv_cnnp_model_div_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_div_t));
2105 model_div->super.isa = &ccv_cnnp_div_isa;
2106 model_div->super.input_size = reciprocal ? 1 : 2;
2107 model_div->super.outputs = &model_div->output;
2108 model_div->super.output_size = 1;
2109 model_div->reciprocal = reciprocal;
2110 ccv_cnnp_model_copy_name(&model_div->super, name);
2111 return (ccv_cnnp_model_t*)model_div;
2112}
2113
2114static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const super, void* const context)
2115{
2116 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2117 return ccv_cnnp_div(self->reciprocal, self->super.name);
2118}
2119
2120// MARK - Sqrt Layer
2121
2122typedef struct {
2123 ccv_cnnp_model_t super;
2124 ccv_nnc_tensor_symbol_t output;
2125} ccv_cnnp_model_sqrt_t;
2126
2127static void _ccv_cnnp_sqrt_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2128{
2129 PRINT(CCV_CLI_VERBOSE, "[cnnp_sqrt_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sqrt_build] -\n"); fflush(stdout); } } while
(0);
2130 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2130, __extension__ __PRETTY_FUNCTION__
); }));
2131 ccv_nnc_tensor_param_t input_params[1];
2132 ccv_nnc_tensor_param_t output_params;
2133 const ccv_nnc_cmd_t sqrt = CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2134 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2134, __extension__ __PRETTY_FUNCTION__); }));
2135 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2136 ccv_nnc_hint_tensor_auto(sqrt, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2137 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2138 ccv_nnc_graph_exec_symbol_new(graph, sqrt, inputs, 1, outputs, output_size, "sqrt");
2139}
2140
2141static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const self, void* const context);
2142
2143static const ccv_cnnp_model_vtab_t ccv_cnnp_sqrt_isa = {
2144 .build = _ccv_cnnp_sqrt_build,
2145 .copy = _ccv_cnnp_sqrt_copy,
2146};
2147
2148ccv_cnnp_model_t* ccv_cnnp_sqrt(const char* const name)
2149{
2150 ccv_cnnp_model_sqrt_t* const model_sqrt = (ccv_cnnp_model_sqrt_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sqrt_t));
2151 model_sqrt->super.isa = &ccv_cnnp_sqrt_isa;
2152 model_sqrt->super.input_size = 1;
2153 model_sqrt->super.outputs = &model_sqrt->output;
2154 model_sqrt->super.output_size = 1;
2155 ccv_cnnp_model_copy_name(&model_sqrt->super, name);
2156 return (ccv_cnnp_model_t*)model_sqrt;
2157}
2158
2159static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const super, void* const context)
2160{
2161 const ccv_cnnp_model_sqrt_t* const self = (const ccv_cnnp_model_sqrt_t*)super;
2162 return ccv_cnnp_sqrt(self->super.name);
2163}
2164
2165// MARK - Cmul Layer
2166
2167typedef struct {
2168 ccv_cnnp_model_t super;
2169 ccv_nnc_tensor_symbol_t output;
2170} ccv_cnnp_model_cmul_t;
2171
2172static void _ccv_cnnp_cmul_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2173{
2174 PRINT(CCV_CLI_VERBOSE, "[cnnp_cmul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_cmul_build] -\n"); fflush(stdout); } } while
(0);
2175 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2175, __extension__ __PRETTY_FUNCTION__); }));
2176 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2176, __extension__ __PRETTY_FUNCTION__
); }));
2177 ccv_nnc_tensor_param_t input_params[2];
2178 int i;
2179 for (i = 0; i < 2; i++)
2180 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2181 ccv_nnc_tensor_param_t output_params;
2182 const ccv_nnc_cmd_t mul = CMD_CMUL_FORWARD()ccv_nnc_cmd(CCV_NNC_CMUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}}}, 0);
2183 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2184 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2185 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "cmul");
2186}
2187
2188static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const self, void* const context);
2189
2190static const ccv_cnnp_model_vtab_t ccv_cnnp_cmul_isa = {
2191 .build = _ccv_cnnp_cmul_build,
2192 .copy = _ccv_cnnp_cmul_copy,
2193};
2194
2195ccv_cnnp_model_t* ccv_cnnp_cmul(const char* const name)
2196{
2197 ccv_cnnp_model_cmul_t* const model_cmul = (ccv_cnnp_model_cmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cmul_t));
2198 model_cmul->super.isa = &ccv_cnnp_cmul_isa;
2199 model_cmul->super.input_size = 2;
2200 model_cmul->super.outputs = &model_cmul->output;
2201 model_cmul->super.output_size = 1;
2202 ccv_cnnp_model_copy_name(&model_cmul->super, name);
2203 return (ccv_cnnp_model_t*)model_cmul;
2204}
2205
2206static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2207{
2208 return ccv_cnnp_cmul(super->name);
2209}
2210
2211// MARK - Transpose Layer
2212
2213typedef struct {
2214 ccv_cnnp_model_t super;
2215 ccv_nnc_tensor_symbol_t output;
2216 int transpose[2];
2217} ccv_cnnp_model_transpose_t;
2218
2219static void _ccv_cnnp_transpose_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2220{
2221 ccv_cnnp_model_transpose_t* const self = (ccv_cnnp_model_transpose_t*)super;
2222 PRINT(CCV_CLI_VERBOSE, "[cnnp_transpose_build] (%d, %d)\n", self->transpose[0], self->transpose[1])do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_transpose_build] (%d, %d)\n", self->transpose
[0], self->transpose[1]); fflush(stdout); } } while (0);
2223 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2223, __extension__ __PRETTY_FUNCTION__); }));
2224 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2224, __extension__ __PRETTY_FUNCTION__
); }));
2225 if (self->transpose[0] == self->transpose[1])
2226 {
2227 outputs[0] = inputs[0];
2228 return;
2229 }
2230 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2231 ccv_nnc_tensor_param_t output_params;
2232 const ccv_nnc_cmd_t transpose = CMD_TRANSPOSE_FORWARD(self->transpose[0], self->transpose[1])ccv_nnc_cmd(CCV_NNC_TRANSPOSE_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.transpose={.axis={self->transpose[
0], self->transpose[1]}}}), 0);
2233 ccv_nnc_hint_tensor_auto(transpose, (ccv_nnc_tensor_param_t []){
2234 params,
2235 }, 1, ccv_nnc_no_hint, &output_params, 1);
2236 const ccv_nnc_tensor_symbol_t transpose_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2237 ccv_nnc_graph_exec_symbol_new(graph, transpose, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(transpose_output)(const ccv_nnc_tensor_symbol_t []){transpose_output}, (1 +1 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
-1), "transpose");
2238 outputs[0] = transpose_output;
2239}
2240
2241static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
2242
2243static const ccv_cnnp_model_vtab_t ccv_cnnp_transpose_isa = {
2244 .build = _ccv_cnnp_transpose_build,
2245 .copy = _ccv_cnnp_transpose_copy,
2246};
2247
2248ccv_cnnp_model_t* ccv_cnnp_transpose(const int axis_a, const int axis_b, const char* const name)
2249{
2250 ccv_cnnp_model_transpose_t* const model_transpose = (ccv_cnnp_model_transpose_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_transpose_t));
2251 model_transpose->super.isa = &ccv_cnnp_transpose_isa;
2252 model_transpose->super.input_size = 1;
2253 model_transpose->super.outputs = &model_transpose->output;
2254 model_transpose->super.output_size = 1;
2255 model_transpose->transpose[0] = axis_a;
2256 model_transpose->transpose[1] = axis_b;
2257 ccv_cnnp_model_copy_name(&model_transpose->super, name);
2258 return (ccv_cnnp_model_t*)model_transpose;
2259}
2260
2261static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
2262{
2263 const ccv_cnnp_model_transpose_t* const self = (const ccv_cnnp_model_transpose_t*)super;
2264 return ccv_cnnp_transpose(self->transpose[0], self->transpose[1], self->super.name);
2265}
2266
2267// MARK - Layer Norm Layer
2268
2269typedef struct {
2270 ccv_cnnp_model_t super;
2271 ccv_nnc_tensor_symbol_t output;
2272 ccv_nnc_tensor_symbol_t bias;
2273 ccv_nnc_tensor_symbol_t scale;
2274 ccv_nnc_cmd_param_t params;
2275} ccv_cnnp_model_layer_norm_t;
2276
2277static void _ccv_cnnp_layer_norm_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2278{
2279 PRINT(CCV_CLI_VERBOSE, "[cnnp_layer_norm_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_layer_norm_build] -\n"); fflush(stdout); } }
while (0);
2280 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2280, __extension__ __PRETTY_FUNCTION__); }));
2281 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2281, __extension__ __PRETTY_FUNCTION__
); }));
2282 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2283 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2284 ccv_nnc_tensor_param_t bias_params = params;
2285 const int nd = ccv_nnc_tensor_nd(params.dim);
2286 int i;
2287 for (i = 0; i < nd; i++)
2288 bias_params.dim[i] = 1;
2289 for (i = 0; i < self->params.lnorm.count; i++)
2290 bias_params.dim[self->params.lnorm.axis[i]] = params.dim[self->params.lnorm.axis[i]];
2291 if (self->params.lnorm.elementwise_affine)
2292 {
2293 // Both scale and bias are shared between if this model is reused.
2294 if (!self->scale.graph)
2295 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2296 if (!self->bias.graph)
2297 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2298 }
2299 const ccv_nnc_cmd_t layer_norm = ccv_nnc_cmd(CCV_NNC_LAYER_NORM_FORWARD, 0, self->params, 0);
2300 ccv_nnc_tensor_param_t output_params[3];
2301 if (self->params.lnorm.elementwise_affine)
2302 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2303 params,
2304 bias_params,
2305 bias_params,
2306 }, 3, ccv_nnc_no_hint, output_params, 3);
2307 else
2308 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2309 params,
2310 }, 1, ccv_nnc_no_hint, output_params, 3);
2311 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2312 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
2313 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
2314 if (self->params.lnorm.elementwise_affine)
2315 ccv_nnc_graph_exec_symbol_new(graph, layer_norm, TENSOR_SYMBOL_LIST(inputs[0], self->scale, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->scale,
self->bias}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_mean, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, saved_mean, saved_inv_std
}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), "layer_norm");
2316 else
2317 ccv_nnc_graph_exec_symbol_new(graph, layer_norm, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_mean, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, saved_mean, saved_inv_std
}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), "layer_norm");
2318 outputs[0] = output;
2319}
2320
2321static void _ccv_cnnp_layer_norm_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
2322{
2323 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2324 if (self->scale.graph)
2325 initializer(context, CMD_SET_FORWARD(1)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), ccv_nnc_no_hint, 0, 0, self->scale);
2326 if (self->bias.graph)
2327 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
2328}
2329
2330static void _ccv_cnnp_layer_norm_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
2331{
2332 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2333 if (self->scale.graph)
2334 add_to_array(parameters, self->scale, is_trainable);
2335 if (self->bias.graph)
2336 add_to_array(parameters, self->bias, is_trainable);
2337}
2338
2339static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
2340
2341static const ccv_cnnp_model_vtab_t ccv_cnnp_layer_norm_isa = {
2342 .build = _ccv_cnnp_layer_norm_build,
2343 .init_states = _ccv_cnnp_layer_norm_init_states,
2344 .add_to_parameter = _ccv_cnnp_layer_norm_add_to_parameter,
2345 .copy = _ccv_cnnp_layer_norm_copy,
2346};
2347
2348ccv_cnnp_model_t* ccv_cnnp_layer_norm(const float epsilon, const int axis[CCV_NNC_MAX_DIM_ALLOC(12)], const int axis_count, const int elementwise_affine, const int is_trainable, const char* const name)
2349{
2350 ccv_cnnp_model_layer_norm_t* const model_layer_norm = (ccv_cnnp_model_layer_norm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_layer_norm_t));
2351 model_layer_norm->super.isa = &ccv_cnnp_layer_norm_isa;
2352 model_layer_norm->super.input_size = 1;
2353 model_layer_norm->super.outputs = &model_layer_norm->output;
2354 model_layer_norm->super.output_size = 1;
2355 model_layer_norm->super.is_trainable = is_trainable;
2356 ccv_cnnp_model_copy_name(&model_layer_norm->super, name);
2357 model_layer_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2358 model_layer_norm->scale.graph = 0;
2359 model_layer_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
2360 model_layer_norm->bias.graph = 0;
2361 model_layer_norm->params.lnorm.epsilon = epsilon;
2362 model_layer_norm->params.lnorm.count = axis_count;
2363 model_layer_norm->params.lnorm.elementwise_affine = elementwise_affine;
2364 memcpy(model_layer_norm->params.lnorm.axis, axis, sizeof(int) * axis_count);
2365 return (ccv_cnnp_model_t*)model_layer_norm;
2366}
2367
2368static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
2369{
2370 const ccv_cnnp_model_layer_norm_t* const self = (const ccv_cnnp_model_layer_norm_t*)super;
2371 return ccv_cnnp_layer_norm(self->params.lnorm.epsilon, self->params.lnorm.axis, self->params.lnorm.count, self->params.lnorm.elementwise_affine, self->super.is_trainable, self->super.name);
2372}
2373
2374// MARK - Group Norm Layer
2375
2376typedef struct {
2377 ccv_cnnp_model_t super;
2378 ccv_nnc_tensor_symbol_t output;
2379 ccv_nnc_tensor_symbol_t bias;
2380 ccv_nnc_tensor_symbol_t scale;
2381 ccv_nnc_cmd_param_t params;
2382} ccv_cnnp_model_group_norm_t;
2383
2384static void _ccv_cnnp_group_norm_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2385{
2386 PRINT(CCV_CLI_VERBOSE, "[cnnp_group_norm_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_group_norm_build] -\n"); fflush(stdout); } }
while (0);
2387 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2387, __extension__ __PRETTY_FUNCTION__); }));
2388 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2388, __extension__ __PRETTY_FUNCTION__
); }));
2389 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2390 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2391 ccv_nnc_tensor_param_t bias_params = params;
2392 const int nd = ccv_nnc_tensor_nd(params.dim);
2393 int i;
2394 for (i = 0; i < nd; i++)
2395 bias_params.dim[i] = 1;
2396 bias_params.dim[self->params.gnorm.group_axis] = params.dim[self->params.gnorm.group_axis];
2397 if (self->params.gnorm.elementwise_affine)
2398 {
2399 // Both scale and bias are shared between if this model is reused.
2400 if (!self->scale.graph)
2401 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2402 if (!self->bias.graph)
2403 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2404 }
2405 const ccv_nnc_cmd_t group_norm = ccv_nnc_cmd(CCV_NNC_GROUP_NORM_FORWARD, 0, self->params, 0);
2406 ccv_nnc_tensor_param_t output_params[3];
2407 if (self->params.gnorm.elementwise_affine)
2408 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
2409 params,
2410 bias_params,
2411 bias_params,
2412 }, 3, ccv_nnc_no_hint, output_params, 3);
2413 else
2414 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
2415 params,
2416 }, 1, ccv_nnc_no_hint, output_params, 3);
2417 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2418 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
2419 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
2420 if (self->params.gnorm.elementwise_affine)
2421 ccv_nnc_graph_exec_symbol_new(graph, group_norm, TENSOR_SYMBOL_LIST(inputs[0], self->scale, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->scale,
self->bias}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_mean, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, saved_mean, saved_inv_std
}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), "group_norm");
2422 else
2423 ccv_nnc_graph_exec_symbol_new(graph, group_norm, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_mean, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, saved_mean, saved_inv_std
}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 -1), "group_norm");
2424 outputs[0] = output;
2425}
2426
2427static void _ccv_cnnp_group_norm_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
2428{
2429 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2430 if (self->scale.graph)
2431 initializer(context, CMD_SET_FORWARD(1)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), ccv_nnc_no_hint, 0, 0, self->scale);
2432 if (self->bias.graph)
2433 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
2434}
2435
2436static void _ccv_cnnp_group_norm_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
2437{
2438 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2439 if (self->scale.graph)
2440 add_to_array(parameters, self->scale, is_trainable);
2441 if (self->bias.graph)
2442 add_to_array(parameters, self->bias, is_trainable);
2443}
2444
2445static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
2446
2447static const ccv_cnnp_model_vtab_t ccv_cnnp_group_norm_isa = {
2448 .build = _ccv_cnnp_group_norm_build,
2449 .init_states = _ccv_cnnp_group_norm_init_states,
2450 .add_to_parameter = _ccv_cnnp_group_norm_add_to_parameter,
2451 .copy = _ccv_cnnp_group_norm_copy,
2452};
2453
2454ccv_cnnp_model_t* ccv_cnnp_group_norm(const int group_axis, const int groups, const float epsilon, const int reduce_axis[CCV_NNC_MAX_DIM_ALLOC(12)], const int axis_count, const int elementwise_affine, const int is_trainable, const char* const name)
2455{
2456 ccv_cnnp_model_group_norm_t* const model_group_norm = (ccv_cnnp_model_group_norm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_group_norm_t));
2457 model_group_norm->super.isa = &ccv_cnnp_group_norm_isa;
2458 model_group_norm->super.input_size = 1;
2459 model_group_norm->super.outputs = &model_group_norm->output;
2460 model_group_norm->super.output_size = 1;
2461 model_group_norm->super.is_trainable = is_trainable;
2462 ccv_cnnp_model_copy_name(&model_group_norm->super, name);
2463 model_group_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2464 model_group_norm->scale.graph = 0;
2465 model_group_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
2466 model_group_norm->bias.graph = 0;
2467 model_group_norm->params.gnorm.group_axis = group_axis;
2468 model_group_norm->params.gnorm.groups = groups;
2469 model_group_norm->params.gnorm.epsilon = epsilon;
2470 model_group_norm->params.gnorm.reduce_count = axis_count;
2471 model_group_norm->params.gnorm.elementwise_affine = elementwise_affine;
2472 memcpy(model_group_norm->params.gnorm.reduce_axis, reduce_axis, sizeof(int) * axis_count);
2473 return (ccv_cnnp_model_t*)model_group_norm;
2474}
2475
2476static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
2477{
2478 const ccv_cnnp_model_group_norm_t* const self = (const ccv_cnnp_model_group_norm_t*)super;
2479 return ccv_cnnp_group_norm(self->params.gnorm.group_axis, self->params.gnorm.groups, self->params.gnorm.epsilon, self->params.gnorm.reduce_axis, self->params.gnorm.reduce_count, self->params.gnorm.elementwise_affine, self->super.is_trainable, self->super.name);
2480}
2481
2482// MARK - RMSNorm Layer
2483
2484typedef struct {
2485 ccv_cnnp_model_t super;
2486 ccv_nnc_tensor_symbol_t output;
2487 ccv_nnc_tensor_symbol_t scale;
2488 ccv_nnc_cmd_param_t params;
2489} ccv_cnnp_model_rmsnorm_t;
2490
2491static void _ccv_cnnp_rmsnorm_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2492{
2493 PRINT(CCV_CLI_VERBOSE, "[cnnp_rmsnorm_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_rmsnorm_build] -\n"); fflush(stdout); } } while
(0);
2494 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2494, __extension__ __PRETTY_FUNCTION__); }));
2495 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2495, __extension__ __PRETTY_FUNCTION__
); }));
2496 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2497 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2498 ccv_nnc_tensor_param_t scale_params = params;
2499 const int nd = ccv_nnc_tensor_nd(params.dim);
2500 int i;
2501 for (i = 0; i < nd; i++)
2502 scale_params.dim[i] = 1;
2503 for (i = 0; i < self->params.rmsnorm.count; i++)
2504 scale_params.dim[self->params.rmsnorm.axis[i]] = params.dim[self->params.rmsnorm.axis[i]];
2505 // Both scale and bias are shared between if this model is reused.
2506 if (!self->scale.graph)
2507 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
2508 const ccv_nnc_cmd_t rmsnorm = ccv_nnc_cmd(CCV_NNC_RMSNORM_FORWARD, 0, self->params, 0);
2509 ccv_nnc_tensor_param_t output_params[2];
2510 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
2511 params,
2512 scale_params,
2513 }, 2, ccv_nnc_no_hint, output_params, 2);
2514 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2515 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_inv_std");
2516 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm, TENSOR_SYMBOL_LIST(inputs[0], self->scale)(const ccv_nnc_tensor_symbol_t []){inputs[0], self->scale}
, (1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_inv_std)(const ccv_nnc_tensor_symbol_t []){output, saved_inv_std}, (1
+1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 -1), "rmsnorm");
2517 outputs[0] = output;
2518}
2519
2520static void _ccv_cnnp_rmsnorm_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
2521{
2522 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2523 if (self->scale.graph)
2524 initializer(context, CMD_SET_FORWARD(1)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), ccv_nnc_no_hint, 0, 0, self->scale);
2525}
2526
2527static void _ccv_cnnp_rmsnorm_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
2528{
2529 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2530 if (self->scale.graph)
2531 add_to_array(parameters, self->scale, is_trainable);
2532}
2533
2534static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context);
2535
2536static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_isa = {
2537 .build = _ccv_cnnp_rmsnorm_build,
2538 .init_states = _ccv_cnnp_rmsnorm_init_states,
2539 .add_to_parameter = _ccv_cnnp_rmsnorm_add_to_parameter,
2540 .copy = _ccv_cnnp_rmsnorm_copy,
2541};
2542
2543ccv_cnnp_model_t* ccv_cnnp_rmsnorm(const float epsilon, const int axis[CCV_NNC_MAX_DIM_ALLOC(12)], const int axis_count, const int is_trainable, const char* const name)
2544{
2545 ccv_cnnp_model_rmsnorm_t* const model_rmsnorm = (ccv_cnnp_model_rmsnorm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_t));
2546 model_rmsnorm->super.isa = &ccv_cnnp_rmsnorm_isa;
2547 model_rmsnorm->super.input_size = 1;
2548 model_rmsnorm->super.outputs = &model_rmsnorm->output;
2549 model_rmsnorm->super.output_size = 1;
2550 model_rmsnorm->super.is_trainable = is_trainable;
2551 ccv_cnnp_model_copy_name(&model_rmsnorm->super, name);
2552 model_rmsnorm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2553 model_rmsnorm->scale.graph = 0;
2554 model_rmsnorm->params.rmsnorm.epsilon = epsilon;
2555 model_rmsnorm->params.rmsnorm.count = axis_count;
2556 memcpy(model_rmsnorm->params.lnorm.axis, axis, sizeof(int) * axis_count);
2557 return (ccv_cnnp_model_t*)model_rmsnorm;
2558}
2559
2560static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context)
2561{
2562 const ccv_cnnp_model_rmsnorm_t* const self = (const ccv_cnnp_model_rmsnorm_t*)super;
2563 return ccv_cnnp_rmsnorm(self->params.rmsnorm.epsilon, self->params.rmsnorm.axis, self->params.rmsnorm.count, self->super.is_trainable, self->super.name);
2564}
2565
2566// MARK - Batched Matrix Mul Layer
2567
2568typedef struct {
2569 ccv_cnnp_model_t super;
2570 ccv_nnc_tensor_symbol_t output;
2571 int transpose_a[2];
2572 int transpose_b[2];
2573 int flags;
2574} ccv_cnnp_model_matmul_t;
2575
2576static void _ccv_cnnp_matmul_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2577{
2578 PRINT(CCV_CLI_VERBOSE, "[cnnp_matmul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_matmul_build] -\n"); fflush(stdout); } } while
(0);
2579 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2579, __extension__ __PRETTY_FUNCTION__); }));
2580 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2580, __extension__ __PRETTY_FUNCTION__
); }));
2581 ccv_cnnp_model_matmul_t* const self = (ccv_cnnp_model_matmul_t*)super;
2582 ccv_nnc_tensor_param_t a_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2583 ccv_nnc_tensor_param_t b_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
2584 ccv_nnc_tensor_param_t output_params;
2585 ccv_nnc_cmd_t matmul = CMD_GEMM_FORWARD(self->transpose_a, self->transpose_b)ccv_nnc_cmd(CCV_NNC_GEMM_FORWARD, 0, ((ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.blas={.a={1,1},.transpose_a={self->transpose_a
[0],self->transpose_a[1]},.transpose_b={self->transpose_b
[0],self->transpose_b[1]},}}), 0);
2586 matmul.info.blas.flags = self->flags;
2587 ccv_nnc_hint_tensor_auto(matmul, (ccv_nnc_tensor_param_t []){
2588 a_params,
2589 b_params,
2590 }, 2, ccv_nnc_no_hint, &output_params, 1);
2591 const ccv_nnc_tensor_symbol_t matmul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2592 ccv_nnc_graph_exec_symbol_new(graph, matmul, inputs, input_size, TENSOR_SYMBOL_LIST(matmul_output)(const ccv_nnc_tensor_symbol_t []){matmul_output}, (1 +1 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1
), "matmul");
2593 outputs[0] = matmul_output;
2594}
2595
2596static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context);
2597
2598static const ccv_cnnp_model_vtab_t ccv_cnnp_matmul_isa = {
2599 .build = _ccv_cnnp_matmul_build,
2600 .copy = _ccv_cnnp_matmul_copy,
2601};
2602
2603ccv_cnnp_model_t* ccv_cnnp_matmul(const int transpose_a[2], const int transpose_b[2], const int flags, const char* const name)
2604{
2605 ccv_cnnp_model_matmul_t* const model_matmul = (ccv_cnnp_model_matmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_matmul_t));
2606 model_matmul->super.isa = &ccv_cnnp_matmul_isa;
2607 model_matmul->super.input_size = 2;
2608 model_matmul->super.outputs = &model_matmul->output;
2609 model_matmul->super.output_size = 1;
2610 model_matmul->transpose_a[0] = transpose_a[0];
2611 model_matmul->transpose_a[1] = transpose_a[1];
2612 model_matmul->transpose_b[0] = transpose_b[0];
2613 model_matmul->transpose_b[1] = transpose_b[1];
2614 model_matmul->flags = flags;
2615 ccv_cnnp_model_copy_name(&model_matmul->super, name);
2616 return (ccv_cnnp_model_t*)model_matmul;
2617}
2618
2619static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2620{
2621 const ccv_cnnp_model_matmul_t* const self = (const ccv_cnnp_model_matmul_t*)super;
2622 return ccv_cnnp_matmul(self->transpose_a, self->transpose_b, self->flags, self->super.name);
2623}
2624
2625// MARK - Dropout Layer
2626
2627typedef struct {
2628 ccv_cnnp_model_t super;
2629 ccv_nnc_tensor_symbol_t output;
2630 ccv_nnc_graph_exec_symbol_t dropout;
2631 float p;
2632 int entirety;
2633} ccv_cnnp_model_dropout_t;
2634
2635static void _ccv_cnnp_dropout_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2636{
2637 PRINT(CCV_CLI_VERBOSE, "[cnnp_dropout_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_dropout_build] -\n"); fflush(stdout); } } while
(0);
2638 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2638, __extension__ __PRETTY_FUNCTION__); }));
2639 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2639, __extension__ __PRETTY_FUNCTION__
); }));
2640 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2641 ccv_nnc_tensor_param_t output_params[2];
2642 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
2643 const ccv_nnc_cmd_t dropout = CMD_DROPOUT_FORWARD(self->p, self->entirety)ccv_nnc_cmd(CCV_NNC_DROPOUT_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.dropout={.p=self->p,.entirety=self
->entirety}}), 0);
2644 ccv_nnc_hint_tensor_auto(dropout, (ccv_nnc_tensor_param_t []){
2645 params,
2646 }, 1, ccv_nnc_no_hint, output_params, 2);
2647 const ccv_nnc_tensor_symbol_t dropout_output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2648 const ccv_nnc_tensor_symbol_t mask = ccv_nnc_tensor_symbol_new(graph, output_params[1], "mask");
2649 self->dropout = ccv_nnc_graph_exec_symbol_new(graph, dropout, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(dropout_output, mask)(const ccv_nnc_tensor_symbol_t []){dropout_output, mask}, (1 +
1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 -1), "dropout");
2650 outputs[0] = dropout_output;
2651}
2652
2653static void _ccv_cnnp_dropout_set_is_test(ccv_cnnp_model_t* const super, const int is_test, const ccv_cnnp_cmd_updater_f updater, void* const context)
2654{
2655 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
2656 if (self->dropout.graph)
2657 {
2658 if (is_test)
2659 // During test, the dropout is not applied. Data transfer is perfect because if these are the same tensor, it will skip.
2660 updater(context, self->dropout, CMD_DATA_TRANSFER_FORWARD()ccv_nnc_cmd(CCV_NNC_DATA_TRANSFER_FORWARD, 0, ccv_nnc_cmd_auto
, 0), ccv_nnc_no_hint);
2661 else
2662 updater(context, self->dropout, CMD_DROPOUT_FORWARD(self->p, self->entirety)ccv_nnc_cmd(CCV_NNC_DROPOUT_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.dropout={.p=self->p,.entirety=self
->entirety}}), 0), ccv_nnc_no_hint);
2663 }
2664}
2665
2666static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context);
2667
2668static const ccv_cnnp_model_vtab_t ccv_cnnp_dropout_isa = {
2669 .build = _ccv_cnnp_dropout_build,
2670 .set_is_test = _ccv_cnnp_dropout_set_is_test,
2671 .copy = _ccv_cnnp_dropout_copy,
2672};
2673
2674ccv_cnnp_model_t* ccv_cnnp_dropout(const float p, const int entirety, const char* const name)
2675{
2676 ccv_cnnp_model_dropout_t* const model_dropout = (ccv_cnnp_model_dropout_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dropout_t));
2677 model_dropout->super.isa = &ccv_cnnp_dropout_isa;
2678 model_dropout->super.input_size = 1;
2679 model_dropout->super.outputs = &model_dropout->output;
2680 model_dropout->super.output_size = 1;
2681 model_dropout->p = p;
2682 model_dropout->entirety = entirety;
2683 ccv_cnnp_model_copy_name(&model_dropout->super, name);
2684 return (ccv_cnnp_model_t*)model_dropout;
2685}
2686
2687static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context)
2688{
2689 const ccv_cnnp_model_dropout_t* const self = (const ccv_cnnp_model_dropout_t*)super;
2690 return ccv_cnnp_dropout(self->p, self->entirety, self->super.name);
2691}
2692
2693// MARK - Masked Fill Layer
2694
2695typedef struct {
2696 ccv_cnnp_model_t super;
2697 ccv_nnc_tensor_symbol_t output;
2698 float eq;
2699 float fill;
2700} ccv_cnnp_model_masked_fill_t;
2701
2702static void _ccv_cnnp_masked_fill_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2703{
2704 PRINT(CCV_CLI_VERBOSE, "[cnnp_masked_fill_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_masked_fill_build] -\n"); fflush(stdout); } }
while (0);
2705 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2705, __extension__ __PRETTY_FUNCTION__); }));
2706 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2706, __extension__ __PRETTY_FUNCTION__
); }));
2707 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2708 ccv_cnnp_model_masked_fill_t* const self = (ccv_cnnp_model_masked_fill_t*)super;
2709 const ccv_nnc_tensor_symbol_t masked_fill_output = ccv_nnc_tensor_symbol_new(graph, params, 0);
2710 ccv_nnc_graph_exec_symbol_new(graph, CMD_MASKED_FILL_FORWARD(self->eq, self->fill)ccv_nnc_cmd(CCV_NNC_MASKED_FILL_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={self->eq, self->fill}
}}, 0), TENSOR_SYMBOL_LIST(inputs[0], inputs[1])(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1]}, (1 +
1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 -1), TENSOR_SYMBOL_LIST(masked_fill_output)(const ccv_nnc_tensor_symbol_t []){masked_fill_output}, (1 +1
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 -1), "masked_fill");
2711 outputs[0] = masked_fill_output;
2712}
2713
2714static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context);
2715
2716static const ccv_cnnp_model_vtab_t ccv_cnnp_masked_fill_isa = {
2717 .build = _ccv_cnnp_masked_fill_build,
2718 .copy = _ccv_cnnp_masked_fill_copy,
2719};
2720
2721ccv_cnnp_model_t* ccv_cnnp_masked_fill(const float eq, const float fill, const char* const name)
2722{
2723 ccv_cnnp_model_masked_fill_t* const model_masked_fill = (ccv_cnnp_model_masked_fill_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_masked_fill_t));
2724 model_masked_fill->super.isa = &ccv_cnnp_masked_fill_isa;
2725 model_masked_fill->super.input_size = 2;
2726 model_masked_fill->super.outputs = &model_masked_fill->output;
2727 model_masked_fill->super.output_size = 1;
2728 model_masked_fill->eq = eq;
2729 model_masked_fill->fill = fill;
2730 ccv_cnnp_model_copy_name(&model_masked_fill->super, name);
2731 return (ccv_cnnp_model_t*)model_masked_fill;
2732}
2733
2734static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context)
2735{
2736 const ccv_cnnp_model_masked_fill_t* const self = (const ccv_cnnp_model_masked_fill_t*)super;
2737 return ccv_cnnp_masked_fill(self->eq, self->fill, self->super.name);
2738}
2739
2740// MARK - Index Select Layer
2741
2742typedef struct {
2743 ccv_cnnp_model_t super;
2744 ccv_nnc_tensor_symbol_t output;
2745} ccv_cnnp_model_index_select_t;
2746
2747static void _ccv_cnnp_index_select_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2748{
2749 PRINT(CCV_CLI_VERBOSE, "[cnnp_index_select_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_index_select_build] -\n"); fflush(stdout); }
} while (0);
2750 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2750, __extension__ __PRETTY_FUNCTION__); }));
2751 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2751, __extension__ __PRETTY_FUNCTION__
); }));
2752 const ccv_nnc_tensor_param_t vocab_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2753 const ccv_nnc_tensor_param_t index_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
2754 ccv_nnc_tensor_param_t output_params;
2755 const ccv_nnc_cmd_t index_select = CMD_INDEX_SELECT_FORWARD()ccv_nnc_cmd(CCV_NNC_INDEX_SELECT_FORWARD, 0, ccv_nnc_cmd_auto
, 0);
2756 ccv_nnc_hint_tensor_auto(index_select, (ccv_nnc_tensor_param_t []){
2757 vocab_params,
2758 index_params,
2759 }, 2, ccv_nnc_no_hint, &output_params, 1);
2760 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2761 ccv_nnc_graph_exec_symbol_new(graph, index_select, TENSOR_SYMBOL_LIST(inputs[0], inputs[1])(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1]}, (1 +
1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "index_select");
2762 outputs[0] = output;
2763}
2764
2765static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context);
2766
2767static const ccv_cnnp_model_vtab_t ccv_cnnp_index_select_isa = {
2768 .build = _ccv_cnnp_index_select_build,
2769 .copy = _ccv_cnnp_index_select_copy,
2770};
2771
2772ccv_cnnp_model_t* ccv_cnnp_index_select(const char* const name)
2773{
2774 ccv_cnnp_model_index_select_t* const model_index_select = (ccv_cnnp_model_index_select_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_index_select_t));
2775 model_index_select->super.isa = &ccv_cnnp_index_select_isa;
2776 model_index_select->super.input_size = 2;
2777 model_index_select->super.outputs = &model_index_select->output;
2778 model_index_select->super.output_size = 1;
2779 ccv_cnnp_model_copy_name(&model_index_select->super, name);
2780 return (ccv_cnnp_model_t*)model_index_select;
2781}
2782
2783static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context)
2784{
2785 ccv_cnnp_model_index_select_t* const self = (ccv_cnnp_model_index_select_t*)super;
2786 return ccv_cnnp_index_select(self->super.name);
2787}
2788
2789// MARK - Embedding Layer
2790
2791typedef struct {
2792 ccv_cnnp_model_t super;
2793 ccv_nnc_tensor_symbol_t output;
2794 ccv_nnc_tensor_symbol_t vocab;
2795 int datatype;
2796 int vocab_size;
2797 int embed_size;
2798} ccv_cnnp_model_embedding_t;
2799
2800static void _ccv_cnnp_embedding_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2801{
2802 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2803 PRINT(CCV_CLI_VERBOSE, "[cnnp_embedding_build] vocab_size: %d, embed_size: %d\n", self->vocab_size, self->embed_size)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_embedding_build] vocab_size: %d, embed_size: %d\n"
, self->vocab_size, self->embed_size); fflush(stdout); }
} while (0);
2804 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2804, __extension__ __PRETTY_FUNCTION__); }));
2805 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2805, __extension__ __PRETTY_FUNCTION__
); }));
2806 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2807 ccv_nnc_tensor_param_t vocab_params = params;
2808 memset(vocab_params.dim, 0, sizeof(vocab_params.dim));
2809 vocab_params.datatype = self->datatype;
2810 vocab_params.dim[0] = self->vocab_size;
2811 vocab_params.dim[1] = self->embed_size;
2812 if (!self->vocab.graph)
2813 self->vocab = ccv_nnc_tensor_symbol_new(graph, vocab_params, "vocab");
2814 assert(self->vocab.graph == graph)((void) sizeof ((self->vocab.graph == graph) ? 1 : 0), __extension__
({ if (self->vocab.graph == graph) ; else __assert_fail (
"self->vocab.graph == graph", "ccv_cnnp_model_addons.c", 2814
, __extension__ __PRETTY_FUNCTION__); }));
2815 ccv_nnc_tensor_param_t output_params;
2816 const ccv_nnc_cmd_t embedding = CMD_INDEX_SELECT_FORWARD()ccv_nnc_cmd(CCV_NNC_INDEX_SELECT_FORWARD, 0, ccv_nnc_cmd_auto
, 0);
2817 ccv_nnc_hint_tensor_auto(embedding, (ccv_nnc_tensor_param_t []){
2818 vocab_params,
2819 params,
2820 }, 2, ccv_nnc_no_hint, &output_params, 1);
2821 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2822 ccv_nnc_graph_exec_symbol_new(graph, embedding, TENSOR_SYMBOL_LIST(self->vocab, inputs[0])(const ccv_nnc_tensor_symbol_t []){self->vocab, inputs[0]}
, (1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "embedding");
2823 outputs[0] = output;
2824}
2825
2826static void _ccv_cnnp_embedding_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
2827{
2828 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2829 const float std = sqrtf(2) / sqrtf(self->vocab_size + self->embed_size);
2830 const float bound = sqrtf(3) * std;
2831 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-bound, bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-bound, bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->vocab);
2832}
2833
2834static void _ccv_cnnp_embedding_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
2835{
2836 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2837 add_to_array(parameters, self->vocab, is_trainable);
2838}
2839
2840static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context);
2841
2842static const ccv_cnnp_model_vtab_t ccv_cnnp_embedding_isa = {
2843 .build = _ccv_cnnp_embedding_build,
2844 .init_states = _ccv_cnnp_embedding_init_states,
2845 .add_to_parameter = _ccv_cnnp_embedding_add_to_parameter,
2846 .copy = _ccv_cnnp_embedding_copy,
2847};
2848
2849ccv_cnnp_model_t* ccv_cnnp_embedding(const int datatype, const int vocab_size, const int embed_size, const int is_trainable, const char* const name)
2850{
2851 ccv_cnnp_model_embedding_t* const model_embedding = (ccv_cnnp_model_embedding_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_embedding_t));
2852 model_embedding->super.isa = &ccv_cnnp_embedding_isa;
2853 model_embedding->super.input_size = 1;
2854 model_embedding->super.outputs = &model_embedding->output;
2855 model_embedding->super.output_size = 1;
2856 model_embedding->super.is_trainable = is_trainable;
2857 ccv_cnnp_model_copy_name(&model_embedding->super, name);
2858 model_embedding->vocab.d = CCV_NNC_NO_TENSOR_SYMBOL;
2859 model_embedding->vocab.graph = 0;
2860 assert(datatype == CCV_32F || datatype == CCV_16F)((void) sizeof ((datatype == CCV_32F || datatype == CCV_16F) ?
1 : 0), __extension__ ({ if (datatype == CCV_32F || datatype
== CCV_16F) ; else __assert_fail ("datatype == CCV_32F || datatype == CCV_16F"
, "ccv_cnnp_model_addons.c", 2860, __extension__ __PRETTY_FUNCTION__
); }));
2861 model_embedding->datatype = datatype;
2862 assert(vocab_size > 0)((void) sizeof ((vocab_size > 0) ? 1 : 0), __extension__ (
{ if (vocab_size > 0) ; else __assert_fail ("vocab_size > 0"
, "ccv_cnnp_model_addons.c", 2862, __extension__ __PRETTY_FUNCTION__
); }));
2863 model_embedding->vocab_size = vocab_size;
2864 assert(embed_size > 0)((void) sizeof ((embed_size > 0) ? 1 : 0), __extension__ (
{ if (embed_size > 0) ; else __assert_fail ("embed_size > 0"
, "ccv_cnnp_model_addons.c", 2864, __extension__ __PRETTY_FUNCTION__
); }));
2865 model_embedding->embed_size = embed_size;
2866 return (ccv_cnnp_model_t*)model_embedding;
2867}
2868
2869static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context)
2870{
2871 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2872 return ccv_cnnp_embedding(self->datatype, self->vocab_size, self->embed_size, self->super.is_trainable, self->super.name);
2873}
2874
2875// MARK - Pool Layers
2876
2877typedef struct {
2878 ccv_cnnp_model_t super;
2879 ccv_nnc_tensor_symbol_t output;
2880 int type;
2881 float width_scale;
2882 float height_scale;
2883 int align_corners;
2884} ccv_cnnp_model_upsample_t;
2885
2886static void _ccv_cnnp_upsample_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2887{
2888 PRINT(CCV_CLI_VERBOSE, "[cnnp_upsample_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_upsample_build] -\n"); fflush(stdout); } } while
(0);
2889 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2889, __extension__ __PRETTY_FUNCTION__); }));
2890 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2890, __extension__ __PRETTY_FUNCTION__
); }));
2891 ccv_cnnp_model_upsample_t* const self = (ccv_cnnp_model_upsample_t*)super;
2892 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2893 ccv_nnc_cmd_t cmd = CMD_UPSAMPLE_FORWARD(self->type, self->width_scale, self->height_scale, self->align_corners)ccv_nnc_cmd(CCV_NNC_UPSAMPLE_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.upsample={.type=self->type,.width_scale
=self->width_scale,.height_scale=self->height_scale,.align_corners
=self->align_corners}}), 0);
2894 ccv_nnc_tensor_param_t output_params;
2895 ccv_nnc_hint_tensor_auto(cmd, &params, 1, ccv_nnc_no_hint, &output_params, 1);
2896 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2897 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0])(const ccv_nnc_tensor_symbol_t []){inputs[0]}, (1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output)(const ccv_nnc_tensor_symbol_t []){output}, (1 +1 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), "upsample");
2898 outputs[0] = output;
2899}
2900
2901static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context);
2902
2903static const ccv_cnnp_model_vtab_t ccv_cnnp_upsample_isa = {
2904 .build = _ccv_cnnp_upsample_build,
2905 .copy = _ccv_cnnp_upsample_copy,
2906};
2907
2908ccv_cnnp_model_t* ccv_cnnp_upsample(const int type, const float width_scale, const float height_scale, const int align_corners, const char* const name)
2909{
2910 ccv_cnnp_model_upsample_t* const model_upsample = (ccv_cnnp_model_upsample_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_upsample_t));
2911 model_upsample->super.isa = &ccv_cnnp_upsample_isa;
2912 model_upsample->super.input_size = 1;
2913 model_upsample->super.outputs = &model_upsample->output;
2914 model_upsample->super.output_size = 1;
2915 ccv_cnnp_model_copy_name(&model_upsample->super, name);
2916 assert(type == CCV_NNC_UPSAMPLE_NEAREST || type == CCV_NNC_UPSAMPLE_BILINEAR)((void) sizeof ((type == CCV_NNC_UPSAMPLE_NEAREST || type == CCV_NNC_UPSAMPLE_BILINEAR
) ? 1 : 0), __extension__ ({ if (type == CCV_NNC_UPSAMPLE_NEAREST
|| type == CCV_NNC_UPSAMPLE_BILINEAR) ; else __assert_fail (
"type == CCV_NNC_UPSAMPLE_NEAREST || type == CCV_NNC_UPSAMPLE_BILINEAR"
, "ccv_cnnp_model_addons.c", 2916, __extension__ __PRETTY_FUNCTION__
); }));
2917 model_upsample->type = type;
2918 model_upsample->width_scale = width_scale;
2919 model_upsample->height_scale = height_scale;
2920 model_upsample->align_corners = align_corners;
2921 return (ccv_cnnp_model_t*)model_upsample;
2922}
2923
2924static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context)
2925{
2926 const ccv_cnnp_model_upsample_t* const self = (const ccv_cnnp_model_upsample_t*)super;
2927 return ccv_cnnp_upsample(self->type, self->width_scale, self->height_scale, self->align_corners, self->super.name);
2928}
2929
2930// MARK - Reduce Sum Layer
2931
2932typedef struct {
2933 ccv_cnnp_model_t super;
2934 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
2935 int count;
2936 ccv_nnc_tensor_symbol_t output;
2937} ccv_cnnp_model_reduce_sum_t;
2938
2939static void _ccv_cnnp_reduce_sum_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2940{
2941 PRINT(CCV_CLI_VERBOSE, "[cnnp_reduce_sum_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reduce_sum_build] -\n"); fflush(stdout); } }
while (0);
2942 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
2943 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2943, __extension__ __PRETTY_FUNCTION__); }));
2944 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2944, __extension__ __PRETTY_FUNCTION__
); }));
2945 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2946 ccv_nnc_tensor_param_t output_params;
2947 ccv_nnc_cmd_t reduce_sum = CMD_REDUCE_SUM_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_SUM_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
2948 int i;
2949 for (i = 0; i < self->count; i++)
2950 reduce_sum.info.reduce.axis[i] = self->axis[i];
2951 reduce_sum.info.reduce.count = self->count;
2952 ccv_nnc_hint_tensor_auto(reduce_sum, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2953 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2954 ccv_nnc_graph_exec_symbol_new(graph, reduce_sum, inputs, input_size, outputs, output_size, "reduce_sum");
2955}
2956
2957static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
2958
2959static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_sum_isa = {
2960 .build = _ccv_cnnp_reduce_sum_build,
2961 .copy = _ccv_cnnp_reduce_sum_copy,
2962};
2963
2964ccv_cnnp_model_t* ccv_cnnp_reduce_sum(const int* const axis, const int axis_count, const char* const name)
2965{
2966 ccv_cnnp_model_reduce_sum_t* const model_reduce_sum = (ccv_cnnp_model_reduce_sum_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reduce_sum_t));
2967 model_reduce_sum->super.isa = &ccv_cnnp_reduce_sum_isa;
2968 model_reduce_sum->super.input_size = 1;
2969 model_reduce_sum->super.outputs = &model_reduce_sum->output;
2970 model_reduce_sum->super.output_size = 1;
2971 ccv_cnnp_model_copy_name(&model_reduce_sum->super, name);
2972 assert(axis_count <= CCV_NNC_MAX_DIM_ALLOC)((void) sizeof ((axis_count <= (12)) ? 1 : 0), __extension__
({ if (axis_count <= (12)) ; else __assert_fail ("axis_count <= CCV_NNC_MAX_DIM_ALLOC"
, "ccv_cnnp_model_addons.c", 2972, __extension__ __PRETTY_FUNCTION__
); }));
2973 int i;
2974 for (i = 0; i < axis_count; i++)
2975 model_reduce_sum->axis[i] = axis[i];
2976 model_reduce_sum->count = axis_count;
2977 return (ccv_cnnp_model_t*)model_reduce_sum;
2978}
2979
2980static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const super, void* const context)
2981{
2982 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
2983 return ccv_cnnp_reduce_sum(self->axis, self->count, self->super.name);
2984}
2985
2986// MARK - Reduce Mean Layer
2987
2988typedef struct {
2989 ccv_cnnp_model_t super;
2990 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
2991 int count;
2992 ccv_nnc_tensor_symbol_t output;
2993} ccv_cnnp_model_reduce_mean_t;
2994
2995static void _ccv_cnnp_reduce_mean_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2996{
2997 PRINT(CCV_CLI_VERBOSE, "[cnnp_reduce_mean_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reduce_mean_build] -\n"); fflush(stdout); } }
while (0);
2998 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
2999 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 2999, __extension__ __PRETTY_FUNCTION__); }));
3000 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3000, __extension__ __PRETTY_FUNCTION__
); }));
3001 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3002 ccv_nnc_tensor_param_t output_params;
3003 ccv_nnc_cmd_t reduce_mean = CMD_REDUCE_MEAN_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_MEAN_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
3004 int i;
3005 for (i = 0; i < self->count; i++)
3006 reduce_mean.info.reduce.axis[i] = self->axis[i];
3007 reduce_mean.info.reduce.count = self->count;
3008 ccv_nnc_hint_tensor_auto(reduce_mean, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3009 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3010 ccv_nnc_graph_exec_symbol_new(graph, reduce_mean, inputs, input_size, outputs, output_size, "reduce_mean");
3011}
3012
3013static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const self, void* const context);
3014
3015static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_mean_isa = {
3016 .build = _ccv_cnnp_reduce_mean_build,
3017 .copy = _ccv_cnnp_reduce_mean_copy,
3018};
3019
3020ccv_cnnp_model_t* ccv_cnnp_reduce_mean(const int* const axis, const int axis_count, const char* const name)
3021{
3022 ccv_cnnp_model_reduce_mean_t* const model_reduce_mean = (ccv_cnnp_model_reduce_mean_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reduce_mean_t));
3023 model_reduce_mean->super.isa = &ccv_cnnp_reduce_mean_isa;
3024 model_reduce_mean->super.input_size = 1;
3025 model_reduce_mean->super.outputs = &model_reduce_mean->output;
3026 model_reduce_mean->super.output_size = 1;
3027 ccv_cnnp_model_copy_name(&model_reduce_mean->super, name);
3028 assert(axis_count <= CCV_NNC_MAX_DIM_ALLOC)((void) sizeof ((axis_count <= (12)) ? 1 : 0), __extension__
({ if (axis_count <= (12)) ; else __assert_fail ("axis_count <= CCV_NNC_MAX_DIM_ALLOC"
, "ccv_cnnp_model_addons.c", 3028, __extension__ __PRETTY_FUNCTION__
); }));
3029 int i;
3030 for (i = 0; i < axis_count; i++)
3031 model_reduce_mean->axis[i] = axis[i];
3032 model_reduce_mean->count = axis_count;
3033 return (ccv_cnnp_model_t*)model_reduce_mean;
3034}
3035
3036static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const super, void* const context)
3037{
3038 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3039 return ccv_cnnp_reduce_mean(self->axis, self->count, self->super.name);
3040}
3041
3042// MARK - Reduce Max Layer
3043
3044typedef struct {
3045 ccv_cnnp_model_t super;
3046 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3047 int count;
3048 ccv_nnc_tensor_symbol_t output;
3049} ccv_cnnp_model_reduce_max_t;
3050
3051static void _ccv_cnnp_reduce_max_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3052{
3053 PRINT(CCV_CLI_VERBOSE, "[cnnp_reduce_max_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reduce_max_build] -\n"); fflush(stdout); } }
while (0);
3054 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3055 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3055, __extension__ __PRETTY_FUNCTION__); }));
3056 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3056, __extension__ __PRETTY_FUNCTION__
); }));
3057 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3058 ccv_nnc_tensor_param_t output_params;
3059 ccv_nnc_cmd_t reduce_max = CMD_REDUCE_MAX_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_MAX_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
3060 int i;
3061 for (i = 0; i < self->count; i++)
3062 reduce_max.info.reduce.axis[i] = self->axis[i];
3063 reduce_max.info.reduce.count = self->count;
3064 ccv_nnc_hint_tensor_auto(reduce_max, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3065 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3066 ccv_nnc_graph_exec_symbol_new(graph, reduce_max, inputs, input_size, outputs, output_size, "reduce_max");
3067}
3068
3069static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const self, void* const context);
3070
3071static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_max_isa = {
3072 .build = _ccv_cnnp_reduce_max_build,
3073 .copy = _ccv_cnnp_reduce_max_copy,
3074};
3075
3076ccv_cnnp_model_t* ccv_cnnp_reduce_max(const int* const axis, const int axis_count, const char* const name)
3077{
3078 ccv_cnnp_model_reduce_max_t* const model_reduce_max = (ccv_cnnp_model_reduce_max_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reduce_max_t));
3079 model_reduce_max->super.isa = &ccv_cnnp_reduce_max_isa;
3080 model_reduce_max->super.input_size = 1;
3081 model_reduce_max->super.outputs = &model_reduce_max->output;
3082 model_reduce_max->super.output_size = 1;
3083 ccv_cnnp_model_copy_name(&model_reduce_max->super, name);
3084 assert(axis_count <= CCV_NNC_MAX_DIM_ALLOC)((void) sizeof ((axis_count <= (12)) ? 1 : 0), __extension__
({ if (axis_count <= (12)) ; else __assert_fail ("axis_count <= CCV_NNC_MAX_DIM_ALLOC"
, "ccv_cnnp_model_addons.c", 3084, __extension__ __PRETTY_FUNCTION__
); }));
3085 int i;
3086 for (i = 0; i < axis_count; i++)
3087 model_reduce_max->axis[i] = axis[i];
3088 model_reduce_max->count = axis_count;
3089 return (ccv_cnnp_model_t*)model_reduce_max;
3090}
3091
3092static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const super, void* const context)
3093{
3094 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3095 return ccv_cnnp_reduce_max(self->axis, self->count, self->super.name);
3096}
3097
3098// MARK - Reduce Min Layer
3099
3100typedef struct {
3101 ccv_cnnp_model_t super;
3102 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3103 int count;
3104 ccv_nnc_tensor_symbol_t output;
3105} ccv_cnnp_model_reduce_min_t;
3106
3107static void _ccv_cnnp_reduce_min_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3108{
3109 PRINT(CCV_CLI_VERBOSE, "[cnnp_reduce_min_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reduce_min_build] -\n"); fflush(stdout); } }
while (0);
3110 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3111 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3111, __extension__ __PRETTY_FUNCTION__); }));
3112 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3112, __extension__ __PRETTY_FUNCTION__
); }));
3113 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3114 ccv_nnc_tensor_param_t output_params;
3115 ccv_nnc_cmd_t reduce_min = CMD_REDUCE_MIN_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_MIN_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
3116 int i;
3117 for (i = 0; i < self->count; i++)
3118 reduce_min.info.reduce.axis[i] = self->axis[i];
3119 reduce_min.info.reduce.count = self->count;
3120 ccv_nnc_hint_tensor_auto(reduce_min, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3121 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3122 ccv_nnc_graph_exec_symbol_new(graph, reduce_min, inputs, input_size, outputs, output_size, "reduce_min");
3123}
3124
3125static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const self, void* const context);
3126
3127static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_min_isa = {
3128 .build = _ccv_cnnp_reduce_min_build,
3129 .copy = _ccv_cnnp_reduce_min_copy,
3130};
3131
3132ccv_cnnp_model_t* ccv_cnnp_reduce_min(const int* const axis, const int axis_count, const char* const name)
3133{
3134 ccv_cnnp_model_reduce_min_t* const model_reduce_min = (ccv_cnnp_model_reduce_min_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reduce_min_t));
3135 model_reduce_min->super.isa = &ccv_cnnp_reduce_min_isa;
3136 model_reduce_min->super.input_size = 1;
3137 model_reduce_min->super.outputs = &model_reduce_min->output;
3138 model_reduce_min->super.output_size = 1;
3139 ccv_cnnp_model_copy_name(&model_reduce_min->super, name);
3140 assert(axis_count <= CCV_NNC_MAX_DIM_ALLOC)((void) sizeof ((axis_count <= (12)) ? 1 : 0), __extension__
({ if (axis_count <= (12)) ; else __assert_fail ("axis_count <= CCV_NNC_MAX_DIM_ALLOC"
, "ccv_cnnp_model_addons.c", 3140, __extension__ __PRETTY_FUNCTION__
); }));
3141 int i;
3142 for (i = 0; i < axis_count; i++)
3143 model_reduce_min->axis[i] = axis[i];
3144 model_reduce_min->count = axis_count;
3145 return (ccv_cnnp_model_t*)model_reduce_min;
3146}
3147
3148static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const super, void* const context)
3149{
3150 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3151 return ccv_cnnp_reduce_min(self->axis, self->count, self->super.name);
3152}
3153
3154// MARK - Reduce Norm2 Layer
3155
3156typedef struct {
3157 ccv_cnnp_model_t super;
3158 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3159 int count;
3160 ccv_nnc_tensor_symbol_t output;
3161} ccv_cnnp_model_reduce_norm2_t;
3162
3163static void _ccv_cnnp_reduce_norm2_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3164{
3165 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
3166 PRINT(CCV_CLI_VERBOSE, "[cnnp_reduce_norm2_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_reduce_norm2_build] -\n"); fflush(stdout); }
} while (0);
3167 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3167, __extension__ __PRETTY_FUNCTION__); }));
3168 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3168, __extension__ __PRETTY_FUNCTION__
); }));
3169 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3170 ccv_nnc_tensor_param_t output_params;
3171 ccv_nnc_cmd_t reduce_norm2 = CMD_REDUCE_NORM2_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_NORM2_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
3172 int i;
3173 for (i = 0; i < self->count; i++)
3174 reduce_norm2.info.reduce.axis[i] = self->axis[i];
3175 reduce_norm2.info.reduce.count = self->count;
3176 ccv_nnc_hint_tensor_auto(reduce_norm2, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3177 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3178 ccv_nnc_graph_exec_symbol_new(graph, reduce_norm2, inputs, input_size, outputs, output_size, "reduce_norm2");
3179}
3180
3181static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const self, void* const context);
3182
3183static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_norm2_isa = {
3184 .build = _ccv_cnnp_reduce_norm2_build,
3185 .copy = _ccv_cnnp_reduce_norm2_copy,
3186};
3187
3188ccv_cnnp_model_t* ccv_cnnp_reduce_norm2(const int* const axis, const int axis_count, const char* const name)
3189{
3190 ccv_cnnp_model_reduce_norm2_t* const model_reduce_norm2 = (ccv_cnnp_model_reduce_norm2_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reduce_norm2_t));
3191 model_reduce_norm2->super.isa = &ccv_cnnp_reduce_norm2_isa;
3192 model_reduce_norm2->super.input_size = 1;
3193 model_reduce_norm2->super.outputs = &model_reduce_norm2->output;
3194 model_reduce_norm2->super.output_size = 1;
3195 ccv_cnnp_model_copy_name(&model_reduce_norm2->super, name);
3196 assert(axis_count <= CCV_NNC_MAX_DIM_ALLOC)((void) sizeof ((axis_count <= (12)) ? 1 : 0), __extension__
({ if (axis_count <= (12)) ; else __assert_fail ("axis_count <= CCV_NNC_MAX_DIM_ALLOC"
, "ccv_cnnp_model_addons.c", 3196, __extension__ __PRETTY_FUNCTION__
); }));
3197 int i;
3198 for (i = 0; i < axis_count; i++)
3199 model_reduce_norm2->axis[i] = axis[i];
3200 model_reduce_norm2->count = axis_count;
3201 return (ccv_cnnp_model_t*)model_reduce_norm2;
3202}
3203
3204static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const super, void* const context)
3205{
3206 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
3207 return ccv_cnnp_reduce_norm2(self->axis, self->count, self->super.name);
3208}
3209
3210// MARK - Argmax Layer
3211
3212typedef struct {
3213 ccv_cnnp_model_t super;
3214 int axis;
3215 ccv_nnc_tensor_symbol_t output;
3216} ccv_cnnp_model_argmax_t;
3217
3218static void _ccv_cnnp_argmax_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3219{
3220 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
3221 PRINT(CCV_CLI_VERBOSE, "[cnnp_argmax_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_argmax_build] -\n"); fflush(stdout); } } while
(0);
3222 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3222, __extension__ __PRETTY_FUNCTION__); }));
3223 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3223, __extension__ __PRETTY_FUNCTION__
); }));
3224 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3225 ccv_nnc_tensor_param_t output_params;
3226 ccv_nnc_cmd_t argmax = CMD_ARGMAX_FORWARD()ccv_nnc_cmd(CCV_NNC_ARGMAX_FORWARD, 0, ((ccv_nnc_cmd_param_t)
{.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}})
, 0);
3227 argmax.info.reduce.axis[0] = self->axis;
3228 argmax.info.reduce.count = 1;
3229 ccv_nnc_hint_tensor_auto(argmax, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3230 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3231 ccv_nnc_graph_exec_symbol_new(graph, argmax, inputs, input_size, outputs, output_size, "argmax");
3232}
3233
3234static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const self, void* const context);
3235
3236static const ccv_cnnp_model_vtab_t ccv_cnnp_argmax_isa = {
3237 .build = _ccv_cnnp_argmax_build,
3238 .copy = _ccv_cnnp_argmax_copy,
3239};
3240
3241ccv_cnnp_model_t* ccv_cnnp_argmax(const int axis, const char* const name)
3242{
3243 ccv_cnnp_model_argmax_t* const model_argmax = (ccv_cnnp_model_argmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmax_t));
3244 model_argmax->super.isa = &ccv_cnnp_argmax_isa;
3245 model_argmax->super.input_size = 1;
3246 model_argmax->super.outputs = &model_argmax->output;
3247 model_argmax->super.output_size = 1;
3248 ccv_cnnp_model_copy_name(&model_argmax->super, name);
3249 model_argmax->axis = axis;
3250 return (ccv_cnnp_model_t*)model_argmax;
3251}
3252
3253static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const super, void* const context)
3254{
3255 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
3256 return ccv_cnnp_argmax(self->axis, self->super.name);
3257}
3258
3259// MARK - Argmin Layer
3260
3261typedef struct {
3262 ccv_cnnp_model_t super;
3263 int axis;
3264 ccv_nnc_tensor_symbol_t output;
3265} ccv_cnnp_model_argmin_t;
3266
3267static void _ccv_cnnp_argmin_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3268{
3269 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
3270 PRINT(CCV_CLI_VERBOSE, "[cnnp_argmin_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_argmin_build] -\n"); fflush(stdout); } } while
(0);
3271 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3271, __extension__ __PRETTY_FUNCTION__); }));
3272 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3272, __extension__ __PRETTY_FUNCTION__
); }));
3273 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3274 ccv_nnc_tensor_param_t output_params;
3275 ccv_nnc_cmd_t argmin = CMD_ARGMIN_FORWARD()ccv_nnc_cmd(CCV_NNC_ARGMIN_FORWARD, 0, ((ccv_nnc_cmd_param_t)
{.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}})
, 0);
3276 argmin.info.reduce.axis[0] = self->axis;
3277 argmin.info.reduce.count = 1;
3278 ccv_nnc_hint_tensor_auto(argmin, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3279 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3280 ccv_nnc_graph_exec_symbol_new(graph, argmin, inputs, input_size, outputs, output_size, "argmin");
3281}
3282
3283static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const self, void* const context);
3284
3285static const ccv_cnnp_model_vtab_t ccv_cnnp_argmin_isa = {
3286 .build = _ccv_cnnp_argmin_build,
3287 .copy = _ccv_cnnp_argmin_copy,
3288};
3289
3290ccv_cnnp_model_t* ccv_cnnp_argmin(const int axis, const char* const name)
3291{
3292 ccv_cnnp_model_argmin_t* const model_argmin = (ccv_cnnp_model_argmin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmin_t));
3293 model_argmin->super.isa = &ccv_cnnp_argmin_isa;
3294 model_argmin->super.input_size = 1;
3295 model_argmin->super.outputs = &model_argmin->output;
3296 model_argmin->super.output_size = 1;
3297 ccv_cnnp_model_copy_name(&model_argmin->super, name);
3298 model_argmin->axis = axis;
3299 return (ccv_cnnp_model_t*)model_argmin;
3300}
3301
3302static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const super, void* const context)
3303{
3304 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
3305 return ccv_cnnp_argmin(self->axis, self->super.name);
3306}
3307
3308// MARK - Min Layer
3309
3310typedef struct {
3311 ccv_cnnp_model_t super;
3312 ccv_nnc_tensor_symbol_t output;
3313} ccv_cnnp_model_min_t;
3314
3315static void _ccv_cnnp_min_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3316{
3317 PRINT(CCV_CLI_VERBOSE, "[cnnp_min_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_min_build] -\n"); fflush(stdout); } } while (
0);
3318 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 3318, __extension__ __PRETTY_FUNCTION__); }));
3319 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3319, __extension__ __PRETTY_FUNCTION__
); }));
3320 ccv_nnc_tensor_param_t input_params[2];
3321 int i;
3322 for (i = 0; i < 2; i++)
3323 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
3324 ccv_nnc_tensor_param_t output_params;
3325 const ccv_nnc_cmd_t min = CMD_MIN_FORWARD()ccv_nnc_cmd(CCV_NNC_MIN_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}}}, 0);
3326 ccv_nnc_hint_tensor_auto(min, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
3327 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3328 ccv_nnc_graph_exec_symbol_new(graph, min, inputs, input_size, outputs, output_size, "min");
3329}
3330
3331static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const self, void* const context);
3332
3333static const ccv_cnnp_model_vtab_t ccv_cnnp_min_isa = {
3334 .build = _ccv_cnnp_min_build,
3335 .copy = _ccv_cnnp_min_copy,
3336};
3337
3338ccv_cnnp_model_t* ccv_cnnp_min(const char* const name)
3339{
3340 ccv_cnnp_model_min_t* const model_min = (ccv_cnnp_model_min_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_min_t));
3341 model_min->super.isa = &ccv_cnnp_min_isa;
3342 model_min->super.input_size = 2;
3343 model_min->super.outputs = &model_min->output;
3344 model_min->super.output_size = 1;
3345 ccv_cnnp_model_copy_name(&model_min->super, name);
3346 return (ccv_cnnp_model_t*)model_min;
3347}
3348
3349static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const super, void* const context)
3350{
3351 const ccv_cnnp_model_min_t* const self = (const ccv_cnnp_model_min_t*)super;
3352 return ccv_cnnp_min(self->super.name);
3353}
3354
3355// MARK - Max Layer
3356
3357typedef struct {
3358 ccv_cnnp_model_t super;
3359 ccv_nnc_tensor_symbol_t output;
3360} ccv_cnnp_model_max_t;
3361
3362static void _ccv_cnnp_max_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3363{
3364 PRINT(CCV_CLI_VERBOSE, "[cnnp_max_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_max_build] -\n"); fflush(stdout); } } while (
0);
3365 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 3365, __extension__ __PRETTY_FUNCTION__); }));
3366 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3366, __extension__ __PRETTY_FUNCTION__
); }));
3367 ccv_nnc_tensor_param_t input_params[2];
3368 int i;
3369 for (i = 0; i < 2; i++)
3370 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
3371 ccv_nnc_tensor_param_t output_params;
3372 const ccv_nnc_cmd_t max = CMD_MAX_FORWARD()ccv_nnc_cmd(CCV_NNC_MAX_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}}}, 0);
3373 ccv_nnc_hint_tensor_auto(max, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
3374 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3375 ccv_nnc_graph_exec_symbol_new(graph, max, inputs, input_size, outputs, output_size, "max");
3376}
3377
3378static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const self, void* const context);
3379
3380static const ccv_cnnp_model_vtab_t ccv_cnnp_max_isa = {
3381 .build = _ccv_cnnp_max_build,
3382 .copy = _ccv_cnnp_max_copy,
3383};
3384
3385ccv_cnnp_model_t* ccv_cnnp_max(const char* const name)
3386{
3387 ccv_cnnp_model_max_t* const model_max = (ccv_cnnp_model_max_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_max_t));
3388 model_max->super.isa = &ccv_cnnp_max_isa;
3389 model_max->super.input_size = 2;
3390 model_max->super.outputs = &model_max->output;
3391 model_max->super.output_size = 1;
3392 ccv_cnnp_model_copy_name(&model_max->super, name);
3393 return (ccv_cnnp_model_t*)model_max;
3394}
3395
3396static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const super, void* const context)
3397{
3398 const ccv_cnnp_model_max_t* const self = (const ccv_cnnp_model_max_t*)super;
3399 return ccv_cnnp_max(self->super.name);
3400}
3401
3402// MARK - LSTM Layer
3403
3404typedef struct {
3405 ccv_cnnp_model_t super;
3406 int masked;
3407 ccv_nnc_tensor_symbol_t output;
3408 ccv_nnc_tensor_symbol_t weights;
3409 ccv_nnc_tensor_symbol_t reserves;
3410 ccv_nnc_cmd_param_t params;
3411 ccv_nnc_graph_exec_symbol_t lstm;
3412} ccv_cnnp_model_lstm_t;
3413
3414static int _ccv_cnnp_lstm_weight_dim(int bidirectional, int num_layers, int input_size, int hidden_size, int proj_size, int bias)
3415{
3416 const int D = !!bidirectional + 1;
3417 if (hidden_size == proj_size)
3418 return (num_layers * (bias ? 8 : 0) + (num_layers - 1) * (hidden_size * 4 * D + hidden_size * 4) + input_size * 4 + hidden_size * 4) * D;
3419 else
3420 return (num_layers * (bias ? 8 : 0) + (num_layers - 1) * (proj_size * 4 * D + proj_size * 4) + (proj_size * 4 + input_size * 4) + num_layers * proj_size) * D;
3421}
3422
3423static void _ccv_cnnp_lstm_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3424{
3425 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3426 PRINT(CCV_CLI_VERBOSE, "[cnnp_lstm_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_lstm_build] -\n"); fflush(stdout); } } while
(0);
3427 assert(input_size == self->super.input_size)((void) sizeof ((input_size == self->super.input_size) ? 1
: 0), __extension__ ({ if (input_size == self->super.input_size
) ; else __assert_fail ("input_size == self->super.input_size"
, "ccv_cnnp_model_addons.c", 3427, __extension__ __PRETTY_FUNCTION__
); }));
3428 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3428, __extension__ __PRETTY_FUNCTION__
); }));
3429 const int proj_size = self->params.rnn.proj_size == 0 ? self->params.rnn.hidden_size : self->params.rnn.proj_size;
3430 ccv_nnc_tensor_param_t input_params[5];
3431 input_params[0]= ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3432 if (input_size == 2)
3433 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3434 input_params[4] = input_params[0];
3435 memset(input_params[4].dim, 0, sizeof(input_params[4].dim));
3436 const int x_nd = ccv_nnc_tensor_nd(input_params[0].dim);
3437 const int feature_count = input_params[0].dim[x_nd - 1];
3438 input_params[4].dim[0] = _ccv_cnnp_lstm_weight_dim(self->params.rnn.bidirectional, self->params.rnn.num_layers, feature_count, self->params.rnn.hidden_size, proj_size, self->params.rnn.bias);
3439 input_params[4].dim[1] = self->params.rnn.hidden_size;
3440 const ccv_nnc_cmd_t lstm = ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0);
3441 ccv_nnc_tensor_param_t output_params[4];
3442 ccv_nnc_hint_tensor_auto(lstm, input_params, 5, ccv_nnc_no_hint, output_params, 4);
3443 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3444 if (!self->weights.graph)
3445 self->weights = ccv_nnc_tensor_symbol_new(graph, input_params[4], "weights");
3446 if (!self->reserves.graph)
3447 self->reserves = ccv_nnc_tensor_symbol_new(graph, output_params[3], "reserves");
3448 const ccv_nnc_tensor_symbol_t mask = input_size == 2 ? inputs[1] : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3449 self->lstm = ccv_nnc_graph_exec_symbol_new(graph, lstm, TENSOR_SYMBOL_LIST(inputs[0], mask, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, self->weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], mask, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, self->weights}, (1 +1 +1
+1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -
1), TENSOR_SYMBOL_LIST(outputs[0], NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, self->reserves)(const ccv_nnc_tensor_symbol_t []){outputs[0], (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, self->reserves}, (1 +1 +
1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
-1), "lstm");
3450}
3451
3452static void _ccv_cnnp_lstm_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
3453{
3454 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3455 if (self->weights.graph)
3456 {
3457 const float stdv = 1.0 / sqrt(self->params.rnn.hidden_size);
3458 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-stdv, stdv)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-stdv, stdv}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
3459 }
3460}
3461
3462static void _ccv_cnnp_lstm_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
3463{
3464 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3465 if (self->weights.graph)
3466 add_to_array(parameters, self->weights, is_trainable);
3467}
3468
3469static void _ccv_cnnp_lstm_set_is_test(ccv_cnnp_model_t* const super, const int is_test, const ccv_cnnp_cmd_updater_f updater, void* const context)
3470{
3471 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3472 if (self->lstm.graph)
3473 {
3474 self->params.rnn.is_test = is_test;
3475 updater(context, self->lstm, ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
3476 }
3477}
3478
3479static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const self, void* const context);
3480
3481static const ccv_cnnp_model_vtab_t ccv_cnnp_lstm_isa = {
3482 .build = _ccv_cnnp_lstm_build,
3483 .init_states = _ccv_cnnp_lstm_init_states,
3484 .add_to_parameter = _ccv_cnnp_lstm_add_to_parameter,
3485 .copy = _ccv_cnnp_lstm_copy,
3486 .set_is_test = _ccv_cnnp_lstm_set_is_test,
3487};
3488
3489ccv_cnnp_model_t* ccv_cnnp_lstm(const int masked, const int hidden_size, const int proj_size, const int num_layers, const int bias, const int batch_first, const int bidirectional, const float dropout, const int is_trainable, const char* const name)
3490{
3491 ccv_cnnp_model_lstm_t* const model_lstm = (ccv_cnnp_model_lstm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_lstm_t));
3492 model_lstm->super.isa = &ccv_cnnp_lstm_isa;
3493 model_lstm->super.input_size = masked ? 2 : 1;
3494 model_lstm->super.outputs = &model_lstm->output;
3495 model_lstm->super.output_size = 1;
3496 model_lstm->super.is_trainable = is_trainable;
3497 ccv_cnnp_model_copy_name(&model_lstm->super, name);
3498 model_lstm->masked = masked;
3499 model_lstm->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
3500 model_lstm->weights.graph = 0;
3501 model_lstm->params.rnn.hidden_size = hidden_size;
3502 model_lstm->params.rnn.proj_size = proj_size;
3503 model_lstm->params.rnn.num_layers = num_layers;
3504 model_lstm->params.rnn.bias = bias;
3505 model_lstm->params.rnn.batch_first = batch_first;
3506 model_lstm->params.rnn.bidirectional = bidirectional;
3507 model_lstm->params.rnn.dropout = dropout;
3508 return (ccv_cnnp_model_t*)model_lstm;
3509}
3510
3511static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const super, void* const context)
3512{
3513 const ccv_cnnp_model_lstm_t* const self = (const ccv_cnnp_model_lstm_t*)super;
3514 return ccv_cnnp_lstm(self->masked, self->params.rnn.hidden_size, self->params.rnn.proj_size, self->params.rnn.num_layers, self->params.rnn.bias, self->params.rnn.batch_first, self->params.rnn.bidirectional, self->params.rnn.dropout, self->super.is_trainable, self->super.name);
3515}
3516
3517/// MARK - Datatype conversion layer.
3518
3519typedef struct {
3520 ccv_cnnp_model_t super;
3521 ccv_nnc_tensor_symbol_t output;
3522 int datatype;
3523 int ref_to_last;
3524} ccv_cnnp_model_datatype_conversion_t;
3525
3526static void _ccv_cnnp_datatype_conversion_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3527{
3528 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
3529 PRINT(CCV_CLI_VERBOSE, "[cnnp_datatype_conversion_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_datatype_conversion_build] -\n"); fflush(stdout
); } } while (0);
3530 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3531 if (self->ref_to_last)
3532 {
3533 assert(input_size > 1)((void) sizeof ((input_size > 1) ? 1 : 0), __extension__ (
{ if (input_size > 1) ; else __assert_fail ("input_size > 1"
, "ccv_cnnp_model_addons.c", 3533, __extension__ __PRETTY_FUNCTION__
); }));
3534 const ccv_nnc_tensor_param_t last_params = ccv_nnc_tensor_symbol_params(graph, inputs[input_size - 1]);
3535 params.datatype = last_params.datatype;
3536 } else
3537 params.datatype = self->datatype;
3538 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3538, __extension__ __PRETTY_FUNCTION__
); }));
3539 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3540 ccv_nnc_graph_exec_symbol_new(graph, CMD_DATATYPE_CONVERSION_FORWARD()ccv_nnc_cmd(CCV_NNC_DATATYPE_CONVERSION_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, output_size, outputs, output_size, 0);
3541}
3542
3543static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const self, void* const context);
3544
3545static const ccv_cnnp_model_vtab_t ccv_cnnp_datatype_conversion_isa = {
3546 .build = _ccv_cnnp_datatype_conversion_build,
3547 .copy = _ccv_cnnp_datatype_conversion_copy,
3548};
3549
3550ccv_cnnp_model_t* ccv_cnnp_datatype_conversion(const int datatype, const int ref_to_last, const char* const name)
3551{
3552 ccv_cnnp_model_datatype_conversion_t* const model_datatype_conversion = (ccv_cnnp_model_datatype_conversion_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_datatype_conversion_t));
3553 model_datatype_conversion->super.isa = &ccv_cnnp_datatype_conversion_isa;
3554 model_datatype_conversion->super.input_size = 0;
3555 model_datatype_conversion->super.outputs = &model_datatype_conversion->output;
3556 model_datatype_conversion->super.output_size = 1;
3557 model_datatype_conversion->datatype = datatype;
3558 model_datatype_conversion->ref_to_last = ref_to_last;
3559 ccv_cnnp_model_copy_name(&model_datatype_conversion->super, name);
3560 return (ccv_cnnp_model_t*)model_datatype_conversion;
3561}
3562
3563static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const super, void* const context)
3564{
3565 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
3566 return ccv_cnnp_datatype_conversion(self->datatype, self->ref_to_last, self->super.name);
3567}
3568
3569/// MARK - Clamp layer.
3570
3571typedef struct {
3572 ccv_cnnp_model_t super;
3573 ccv_nnc_tensor_symbol_t output;
3574 float min;
3575 float max;
3576} ccv_cnnp_model_clamp_t;
3577
3578static void _ccv_cnnp_clamp_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3579{
3580 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
3581 PRINT(CCV_CLI_VERBOSE, "[cnnp_clamp_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_clamp_build] -\n"); fflush(stdout); } } while
(0);
3582 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3583 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3583, __extension__ __PRETTY_FUNCTION__
); }));
3584 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3585 ccv_nnc_graph_exec_symbol_new(graph, CMD_CLAMP_FORWARD(self->min, self->max)ccv_nnc_cmd(CCV_NNC_CLAMP_FORWARD, 0, (ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.clamp={.min=self->min,.max=self->max
}}, 0), inputs, output_size, outputs, output_size, 0);
3586}
3587
3588static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const self, void* const context);
3589
3590static const ccv_cnnp_model_vtab_t ccv_cnnp_clamp_isa = {
3591 .build = _ccv_cnnp_clamp_build,
3592 .copy = _ccv_cnnp_clamp_copy,
3593};
3594
3595ccv_cnnp_model_t* ccv_cnnp_clamp(const float min, const float max, const char* const name)
3596{
3597 ccv_cnnp_model_clamp_t* const model_clamp = (ccv_cnnp_model_clamp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_clamp_t));
3598 model_clamp->super.isa = &ccv_cnnp_clamp_isa;
3599 model_clamp->super.input_size = 0;
3600 model_clamp->super.outputs = &model_clamp->output;
3601 model_clamp->super.output_size = 1;
3602 model_clamp->min = min;
3603 model_clamp->max = max;
3604 ccv_cnnp_model_copy_name(&model_clamp->super, name);
3605 return (ccv_cnnp_model_t*)model_clamp;
3606}
3607
3608static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const super, void* const context)
3609{
3610 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
3611 return ccv_cnnp_clamp(self->min, self->max, self->super.name);
3612}
3613
3614// MARK - Parameter Layer
3615
3616typedef struct {
3617 ccv_cnnp_model_t super;
3618 float init_bound;
3619 ccv_nnc_tensor_symbol_t weights;
3620 ccv_nnc_tensor_param_t weights_params;
3621 ccv_nnc_tensor_symbol_t output;
3622} ccv_cnnp_model_parameter_t;
3623
3624static void _ccv_cnnp_parameter_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3625{
3626 PRINT(CCV_CLI_VERBOSE, "[cnnp_parameter_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_parameter_build] -\n"); fflush(stdout); } } while
(0);
3627 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3627, __extension__ __PRETTY_FUNCTION__
); }));
3628 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3629 if (!self->weights.graph)
3630 self->weights = ccv_nnc_tensor_symbol_new(graph, self->weights_params, "weights");
3631 assert(self->weights.graph == graph)((void) sizeof ((self->weights.graph == graph) ? 1 : 0), __extension__
({ if (self->weights.graph == graph) ; else __assert_fail
("self->weights.graph == graph", "ccv_cnnp_model_addons.c"
, 3631, __extension__ __PRETTY_FUNCTION__); }));
3632 outputs[0] = self->weights;
3633}
3634
3635static void _ccv_cnnp_parameter_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
3636{
3637 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3638 if (self->init_bound > 0)
3639 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-self->init_bound, self->init_bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-self->init_bound, self->
init_bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
3640 else
3641 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
3642}
3643
3644static void _ccv_cnnp_parameter_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
3645{
3646 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3647 add_to_array(parameters, self->weights, is_trainable);
3648}
3649
3650static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context);
3651
3652static const ccv_cnnp_model_vtab_t ccv_cnnp_parameter_isa = {
3653 .build = _ccv_cnnp_parameter_build,
3654 .init_states = _ccv_cnnp_parameter_init_states,
3655 .add_to_parameter = _ccv_cnnp_parameter_add_to_parameter,
3656 .copy = _ccv_cnnp_parameter_copy,
3657};
3658
3659ccv_cnnp_model_t* ccv_cnnp_parameter(const ccv_nnc_tensor_param_t params, const float init_bound, const int is_trainable, const char* const name)
3660{
3661 ccv_cnnp_model_parameter_t* const model_parameter = (ccv_cnnp_model_parameter_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_parameter_t));
3662 model_parameter->super.isa = &ccv_cnnp_parameter_isa;
3663 model_parameter->super.input_size = 0;
3664 model_parameter->super.outputs = &model_parameter->output;
3665 model_parameter->super.output_size = 1;
3666 model_parameter->super.is_trainable = is_trainable;
3667 ccv_cnnp_model_copy_name(&model_parameter->super, name);
3668 model_parameter->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
3669 model_parameter->weights.graph = 0;
3670 model_parameter->weights_params = params;
3671 return (ccv_cnnp_model_t*)model_parameter;
3672}
3673
3674static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context)
3675{
3676 const ccv_cnnp_model_parameter_t* const self = (const ccv_cnnp_model_parameter_t*)super;
3677 return ccv_cnnp_parameter(self->weights_params, self->init_bound, self->super.is_trainable, self->super.name);
3678}
3679
3680// MARK - Scalar Layer
3681
3682typedef struct {
3683 ccv_cnnp_model_t super;
3684 int type;
3685 int format;
3686 int datatype;
3687 float value;
3688 ccv_nnc_tensor_symbol_t output;
3689} ccv_cnnp_model_scalar_t;
3690
3691static void _ccv_cnnp_scalar_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3692{
3693 PRINT(CCV_CLI_VERBOSE, "[cnnp_scalar_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_scalar_build] -\n"); fflush(stdout); } } while
(0);
3694 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3694, __extension__ __PRETTY_FUNCTION__
); }));
3695 ccv_cnnp_model_scalar_t* const self = (ccv_cnnp_model_scalar_t*)super;
3696 ccv_nnc_tensor_param_t params = {
3697 .type = self->type,
3698 .format = self->format,
3699 .datatype = self->datatype,
3700 .dim = {
3701 1
3702 }
3703 };
3704 if (input_size > 0)
3705 {
3706 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3707 params.type = input_params.type;
3708 params.format = input_params.format;
3709 params.datatype = input_params.datatype;
3710 }
3711 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3712 ccv_nnc_graph_exec_symbol_new(graph, CMD_SET_FORWARD(self->value)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={self->value,}}}, 0), 0, 0, outputs, 1, 0);
3713}
3714
3715static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context);
3716
3717static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_isa = {
3718 .build = _ccv_cnnp_scalar_build,
3719 .copy = _ccv_cnnp_scalar_copy,
3720};
3721
3722ccv_cnnp_model_t* ccv_cnnp_scalar(const int type, const int format, const int datatype, const float value, const char* const name)
3723{
3724 ccv_cnnp_model_scalar_t* const model_scalar = (ccv_cnnp_model_scalar_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scalar_t));
3725 model_scalar->super.isa = &ccv_cnnp_scalar_isa;
3726 model_scalar->super.input_size = 0;
3727 model_scalar->super.outputs = &model_scalar->output;
3728 model_scalar->super.output_size = 1;
3729 ccv_cnnp_model_copy_name(&model_scalar->super, name);
3730 model_scalar->type = type;
3731 model_scalar->format = format;
3732 model_scalar->datatype = datatype;
3733 model_scalar->value = value;
3734 return (ccv_cnnp_model_t*)model_scalar;
3735}
3736
3737static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context)
3738{
3739 const ccv_cnnp_model_scalar_t* const self = (const ccv_cnnp_model_scalar_t*)super;
3740 return ccv_cnnp_scalar(self->type, self->format, self->datatype, self->value, self->super.name);
3741}
3742
3743// MARK - Variable Layer
3744
3745typedef struct {
3746 ccv_cnnp_model_t super;
3747 ccv_nnc_tensor_param_t params;
3748 ccv_nnc_tensor_symbol_t output;
3749} ccv_cnnp_model_variable_t;
3750
3751static void _ccv_cnnp_variable_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3752{
3753 PRINT(CCV_CLI_VERBOSE, "[cnnp_variable_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_variable_build] -\n"); fflush(stdout); } } while
(0);
3754 assert(input_size == 0)((void) sizeof ((input_size == 0) ? 1 : 0), __extension__ ({ if
(input_size == 0) ; else __assert_fail ("input_size == 0", "ccv_cnnp_model_addons.c"
, 3754, __extension__ __PRETTY_FUNCTION__); }));
3755 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3755, __extension__ __PRETTY_FUNCTION__
); }));
3756 ccv_cnnp_model_variable_t* const self = (ccv_cnnp_model_variable_t*)super;
3757 outputs[0] = ccv_nnc_tensor_symbol_new(graph, self->params, 0);
3758}
3759
3760static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context);
3761
3762static const ccv_cnnp_model_vtab_t ccv_cnnp_variable_isa = {
3763 .build = _ccv_cnnp_variable_build,
3764 .copy = _ccv_cnnp_variable_copy,
3765};
3766
3767ccv_cnnp_model_t* ccv_cnnp_variable(const ccv_nnc_tensor_param_t params, const char* const name)
3768{
3769 ccv_cnnp_model_variable_t* const model_variable = (ccv_cnnp_model_variable_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_variable_t));
3770 model_variable->super.isa = &ccv_cnnp_variable_isa;
3771 model_variable->super.input_size = 0;
3772 model_variable->super.outputs = &model_variable->output;
3773 model_variable->super.output_size = 1;
3774 ccv_cnnp_model_copy_name(&model_variable->super, name);
3775 model_variable->params = params;
3776 return (ccv_cnnp_model_t*)model_variable;
3777}
3778
3779static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context)
3780{
3781 const ccv_cnnp_model_variable_t* const self = (const ccv_cnnp_model_variable_t*)super;
3782 return ccv_cnnp_variable(self->params, self->super.name);
3783}
3784
3785// MARK - Move Layer
3786
3787typedef struct {
3788 ccv_cnnp_model_t super;
3789 ccv_nnc_tensor_symbol_t output;
3790} ccv_cnnp_model_move_t;
3791
3792static void _ccv_cnnp_move_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3793{
3794 PRINT(CCV_CLI_VERBOSE, "[cnnp_move_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_move_build] -\n"); fflush(stdout); } } while
(0);
3795 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 3795, __extension__ __PRETTY_FUNCTION__); }));
3796 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3796, __extension__ __PRETTY_FUNCTION__
); }));
3797 outputs[0] = inputs[1];
3798 ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, 1, outputs, 1, "move");
3799}
3800
3801static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context);
3802
3803static const ccv_cnnp_model_vtab_t ccv_cnnp_move_isa = {
3804 .build = _ccv_cnnp_move_build,
3805 .copy = _ccv_cnnp_move_copy,
3806};
3807
3808ccv_cnnp_model_t* ccv_cnnp_move(const char* const name)
3809{
3810 ccv_cnnp_model_move_t* const model_move = (ccv_cnnp_model_move_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_move_t));
3811 model_move->super.isa = &ccv_cnnp_move_isa;
3812 model_move->super.input_size = 2;
3813 model_move->super.outputs = &model_move->output;
3814 model_move->super.output_size = 1;
3815 ccv_cnnp_model_copy_name(&model_move->super, name);
3816 return (ccv_cnnp_model_t*)model_move;
3817}
3818
3819static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context)
3820{
3821 const ccv_cnnp_model_move_t* const self = (const ccv_cnnp_model_move_t*)super;
3822 return ccv_cnnp_move(self->super.name);
3823}
3824
3825// MARK - "Making" Contiguous Layer
3826
3827typedef struct {
3828 ccv_cnnp_model_t super;
3829 ccv_nnc_tensor_symbol_t output;
3830} ccv_cnnp_model_contiguous_t;
3831
3832static void _ccv_cnnp_contiguous_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3833{
3834 PRINT(CCV_CLI_VERBOSE, "[cnnp_contiguous_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_contiguous_build] -\n"); fflush(stdout); } }
while (0);
3835 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3835, __extension__ __PRETTY_FUNCTION__); }));
3836 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3836, __extension__ __PRETTY_FUNCTION__
); }));
3837 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3838 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
3839 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
3840 {
3841 outputs[0] = inputs[0];
3842 return;
3843 }
3844 // Otherwise, we need to check its stride to know if it is contiguous.
3845 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
3846 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
3847 // We identify permute by checking if the stride is not in descending order.
3848 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
3849 if (ccv_nnc_is_tensor_stride_packed(old_stride, params.dim))
3850 {
3851 outputs[0] = inputs[0];
3852 return;
3853 }
3854 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3855 ccv_nnc_graph_exec_symbol_t make_contiguous = ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, 1, outputs, 1, "contiguous");
3856 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
3857}
3858
3859static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context);
3860
3861static const ccv_cnnp_model_vtab_t ccv_cnnp_contiguous_isa = {
3862 .build = _ccv_cnnp_contiguous_build,
3863 .copy = _ccv_cnnp_contiguous_copy,
3864};
3865
3866ccv_cnnp_model_t* ccv_cnnp_contiguous(const char* const name)
3867{
3868 ccv_cnnp_model_contiguous_t* const model_contiguous = (ccv_cnnp_model_contiguous_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_contiguous_t));
3869 model_contiguous->super.isa = &ccv_cnnp_contiguous_isa;
3870 model_contiguous->super.input_size = 1;
3871 model_contiguous->super.outputs = &model_contiguous->output;
3872 model_contiguous->super.output_size = 1;
3873 ccv_cnnp_model_copy_name(&model_contiguous->super, name);
3874 return (ccv_cnnp_model_t*)model_contiguous;
3875}
3876
3877static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context)
3878{
3879 const ccv_cnnp_model_contiguous_t* const self = (const ccv_cnnp_model_contiguous_t*)super;
3880 return ccv_cnnp_contiguous(self->super.name);
3881}
3882
3883// MARK - "Making" Copy Layer
3884
3885typedef struct {
3886 ccv_cnnp_model_t super;
3887 ccv_nnc_tensor_symbol_t output;
3888} ccv_cnnp_model_copy_t;
3889
3890static void _ccv_cnnp_copy_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3891{
3892 PRINT(CCV_CLI_VERBOSE, "[cnnp_copy_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_copy_build] -\n"); fflush(stdout); } } while
(0);
3893 assert(input_size == 1)((void) sizeof ((input_size == 1) ? 1 : 0), __extension__ ({ if
(input_size == 1) ; else __assert_fail ("input_size == 1", "ccv_cnnp_model_addons.c"
, 3893, __extension__ __PRETTY_FUNCTION__); }));
3894 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3894, __extension__ __PRETTY_FUNCTION__
); }));
3895 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3896 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
3897 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
3898 {
3899 outputs[0] = inputs[0];
3900 return;
3901 }
3902 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3903 ccv_nnc_graph_exec_symbol_t make_contiguous = ccv_nnc_graph_exec_symbol_new(graph, CMD_FORMAT_TRANSFORM_FORWARD()ccv_nnc_cmd(CCV_NNC_FORMAT_TRANSFORM_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, 1, outputs, 1, "contiguous");
3904 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
3905}
3906
3907static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context);
3908
3909static const ccv_cnnp_model_vtab_t ccv_cnnp_copy_isa = {
3910 .build = _ccv_cnnp_copy_build,
3911 .copy = _ccv_cnnp_copy_copy,
3912};
3913
3914ccv_cnnp_model_t* ccv_cnnp_copy(const char* const name)
3915{
3916 ccv_cnnp_model_copy_t* const model_copy = (ccv_cnnp_model_copy_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_copy_t));
3917 model_copy->super.isa = &ccv_cnnp_copy_isa;
3918 model_copy->super.input_size = 1;
3919 model_copy->super.outputs = &model_copy->output;
3920 model_copy->super.output_size = 1;
3921 ccv_cnnp_model_copy_name(&model_copy->super, name);
3922 return (ccv_cnnp_model_t*)model_copy;
3923}
3924
3925static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context)
3926{
3927 const ccv_cnnp_model_copy_t* const self = (const ccv_cnnp_model_copy_t*)super;
3928 return ccv_cnnp_copy(self->super.name);
3929}
3930
3931// MARK - Scaled-Dot Product Attention Layer
3932
3933typedef struct {
3934 ccv_cnnp_model_t super;
3935 ccv_nnc_tensor_symbol_t output;
3936 ccv_nnc_tensor_symbol_t weights;
3937 ccv_nnc_tensor_symbol_t bias;
3938 float scale;
3939 int is_causal;
3940 int has_attn_mask;
3941 int flags;
3942 int fused_unify_head_weights;
3943 int no_bias;
3944} ccv_cnnp_model_scaled_dot_product_attention_t;
3945
3946static void _ccv_cnnp_scaled_dot_product_attention_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
3947{
3948 PRINT(CCV_CLI_VERBOSE, "[cnnp_scaled_dot_product_attention_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_scaled_dot_product_attention_build] -\n"); fflush
(stdout); } } while (0);
3949 assert(input_size == 3 || input_size == 4)((void) sizeof ((input_size == 3 || input_size == 4) ? 1 : 0)
, __extension__ ({ if (input_size == 3 || input_size == 4) ; else
__assert_fail ("input_size == 3 || input_size == 4", "ccv_cnnp_model_addons.c"
, 3949, __extension__ __PRETTY_FUNCTION__); }));
3950 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 3950, __extension__ __PRETTY_FUNCTION__
); }));
3951 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
3952 const ccv_nnc_tensor_param_t q_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3953 const ccv_nnc_tensor_param_t k_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3954 const ccv_nnc_tensor_param_t v_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
3955 const int v_nd = ccv_nnc_tensor_nd(v_params.dim);
3956 assert(v_nd == 3 || v_nd == 4)((void) sizeof ((v_nd == 3 || v_nd == 4) ? 1 : 0), __extension__
({ if (v_nd == 3 || v_nd == 4) ; else __assert_fail ("v_nd == 3 || v_nd == 4"
, "ccv_cnnp_model_addons.c", 3956, __extension__ __PRETTY_FUNCTION__
); }));
3957 const int hEv = (v_nd == 3 ? 1 : v_params.dim[2]) * v_params.dim[v_nd - 1];
3958 ccv_nnc_tensor_param_t weights_params = q_params;
3959 memset(weights_params.dim, 0, sizeof(weights_params.dim));
3960 weights_params.dim[0] = hEv;
3961 weights_params.dim[1] = hEv;
3962 ccv_nnc_tensor_param_t bias_params = q_params;
3963 memset(bias_params.dim, 0, sizeof(bias_params.dim));
3964 bias_params.dim[0] = hEv;
3965 ccv_nnc_cmd_t cmd = {0};
3966 cmd.cmd = CCV_NNC_SCALED_DOT_PRODUCT_ATTENTION_FORWARD;
3967 cmd.info.scaled_dot_product_attention.scale = self->scale;
3968 cmd.info.scaled_dot_product_attention.is_causal = self->is_causal;
3969 cmd.info.scaled_dot_product_attention.flags = self->flags;
3970 ccv_nnc_tensor_param_t output_params[3];
3971 ccv_nnc_tensor_symbol_t output;
3972 ccv_nnc_tensor_symbol_t saved_softmax_lse;
3973 ccv_nnc_tensor_symbol_t saved_v_proj = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3974 ccv_nnc_tensor_symbol_t attn_mask = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3975 ccv_nnc_tensor_symbol_t weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3976 ccv_nnc_tensor_symbol_t bias = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3977 if (self->has_attn_mask)
3978 attn_mask = inputs[3];
3979 if (self->fused_unify_head_weights)
3980 {
3981 if (!self->weights.graph)
3982 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
3983 weights = self->weights;
3984 if (!self->no_bias)
3985 {
3986 if (!self->bias.graph)
3987 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
3988 bias = self->bias;
3989 }
3990 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
3991 q_params,
3992 k_params,
3993 v_params,
3994 (ccv_nnc_tensor_param_t){},
3995 weights_params,
3996 bias_params,
3997 }, 6, ccv_nnc_no_hint, output_params, 3);
3998 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3999 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4000 saved_v_proj = ccv_nnc_tensor_symbol_new(graph, output_params[2], 0);
4001 } else {
4002 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
4003 q_params,
4004 k_params,
4005 v_params,
4006 }, 3, ccv_nnc_no_hint, output_params, 2);
4007 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4008 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4009 }
4010 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], attn_mask, weights, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], attn_mask, weights, bias}, (1 +1 +1 +1 +1 +1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_SYMBOL_LIST(output, saved_softmax_lse, saved_v_proj)(const ccv_nnc_tensor_symbol_t []){output, saved_softmax_lse,
saved_v_proj}, (1 +1 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 -1), "scaled_dot_product_attention");
4011 outputs[0] = output;
4012}
4013
4014static void _ccv_cnnp_scaled_dot_product_attention_init_states(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_cnnp_state_initializer_f initializer, void* const context)
4015{
4016 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4017 if (self->weights.graph)
4018 {
4019 assert(self->fused_unify_head_weights)((void) sizeof ((self->fused_unify_head_weights) ? 1 : 0),
__extension__ ({ if (self->fused_unify_head_weights) ; else
__assert_fail ("self->fused_unify_head_weights", "ccv_cnnp_model_addons.c"
, 4019, __extension__ __PRETTY_FUNCTION__); }));
4020 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
4021 const int c = weight_params.dim[1];
4022 const float std = sqrtf(2) / sqrtf(c);
4023 const float bound = sqrtf(3) * std;
4024 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-bound, bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-bound, bound}}}, 0), ccv_nnc_no_hint, 0, 0, self->weights);
4025 if (self->bias.graph)
4026 initializer(context, CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, self->bias);
4027 }
4028}
4029
4030static void _ccv_cnnp_scaled_dot_product_attention_add_to_parameter(ccv_cnnp_model_t* const super, const ccv_cnnp_add_to_array_f add_to_array, void* const parameters, const int is_trainable)
4031{
4032 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4033 if (self->weights.graph)
4034 {
4035 assert(self->fused_unify_head_weights)((void) sizeof ((self->fused_unify_head_weights) ? 1 : 0),
__extension__ ({ if (self->fused_unify_head_weights) ; else
__assert_fail ("self->fused_unify_head_weights", "ccv_cnnp_model_addons.c"
, 4035, __extension__ __PRETTY_FUNCTION__); }));
4036 add_to_array(parameters, self->weights, is_trainable);
4037 if (self->bias.graph)
4038 add_to_array(parameters, self->bias, is_trainable);
4039 }
4040}
4041
4042static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context);
4043
4044static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_isa = {
4045 .build = _ccv_cnnp_scaled_dot_product_attention_build,
4046 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
4047};
4048
4049static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_fused_isa = {
4050 .build = _ccv_cnnp_scaled_dot_product_attention_build,
4051 .init_states = _ccv_cnnp_scaled_dot_product_attention_init_states,
4052 .add_to_parameter = _ccv_cnnp_scaled_dot_product_attention_add_to_parameter,
4053 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
4054};
4055
4056ccv_cnnp_model_t* ccv_cnnp_scaled_dot_product_attention(const float scale, const int is_causal, const int has_attn_mask, const int flags, const int fused_unify_head_weights, const int no_bias, const int is_trainable, const char* const name)
4057{
4058 ccv_cnnp_model_scaled_dot_product_attention_t* const model_scaled_dot_product_attention = (ccv_cnnp_model_scaled_dot_product_attention_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scaled_dot_product_attention_t));
4059 model_scaled_dot_product_attention->super.isa = fused_unify_head_weights ? &ccv_cnnp_scaled_dot_product_attention_fused_isa : &ccv_cnnp_scaled_dot_product_attention_isa;
4060 model_scaled_dot_product_attention->super.input_size = has_attn_mask ? 4 : 3;
4061 model_scaled_dot_product_attention->super.outputs = &model_scaled_dot_product_attention->output;
4062 model_scaled_dot_product_attention->super.output_size = 1;
4063 model_scaled_dot_product_attention->super.is_trainable = is_trainable;
4064 ccv_cnnp_model_copy_name(&model_scaled_dot_product_attention->super, name);
4065 model_scaled_dot_product_attention->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4066 model_scaled_dot_product_attention->weights.graph = 0;
4067 model_scaled_dot_product_attention->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
4068 model_scaled_dot_product_attention->bias.graph = 0;
4069 model_scaled_dot_product_attention->scale = scale;
4070 model_scaled_dot_product_attention->is_causal = is_causal;
4071 model_scaled_dot_product_attention->has_attn_mask = has_attn_mask;
4072 model_scaled_dot_product_attention->flags = flags;
4073 model_scaled_dot_product_attention->fused_unify_head_weights = fused_unify_head_weights;
4074 model_scaled_dot_product_attention->no_bias = no_bias;
4075 return (ccv_cnnp_model_t*)model_scaled_dot_product_attention;
4076}
4077
4078static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context)
4079{
4080 const ccv_cnnp_model_scaled_dot_product_attention_t* const self = (const ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4081 return ccv_cnnp_scaled_dot_product_attention(self->scale, self->is_causal, self->has_attn_mask, self->flags, self->fused_unify_head_weights, self->no_bias, self->super.is_trainable, self->super.name);
4082}
4083
4084// MARK - Debug Layer
4085
4086typedef struct {
4087 ccv_cnnp_model_t super;
4088 ccv_nnc_tensor_symbol_t output;
4089 ccv_cnnp_model_debug_f debugger;
4090 ccv_cnnp_model_debug_context_deinit_f debug_deinit;
4091 ccv_cnnp_model_debug_context_copy_f debug_copy;
4092 void* debug_context;
4093} ccv_cnnp_model_debug_t;
4094
4095static int _ccv_cnnp_debug_exec(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
4096{
4097 if (cmd.cmd == CCV_NNC_CUSTOM_BACKWARD)
4098 {
4099 assert(0 && "don't support debug backward pass yet")((void) sizeof ((0 && "don't support debug backward pass yet"
) ? 1 : 0), __extension__ ({ if (0 && "don't support debug backward pass yet"
) ; else __assert_fail ("0 && \"don't support debug backward pass yet\""
, "ccv_cnnp_model_addons.c", 4099, __extension__ __PRETTY_FUNCTION__
); }));
4100 }
4101 ccv_cnnp_model_debug_t* const self = (ccv_cnnp_model_debug_t*)cmd.data;
4102 self->debugger(inputs, input_size, stream_context, self->debug_context);
4103 return CCV_NNC_EXEC_SUCCESS;
4104}
4105
4106static ccv_nnc_cmd_vtab_t ccv_cnnp_debug_exec_isa = {
4107 .exec = _ccv_cnnp_debug_exec
4108};
4109
4110static void _ccv_cnnp_debug_build(ccv_cnnp_model_t* const self, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
4111{
4112 PRINT(CCV_CLI_VERBOSE, "[cnnp_debug_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_debug_build] -\n"); fflush(stdout); } } while
(0);
4113 assert(input_size >= 1)((void) sizeof ((input_size >= 1) ? 1 : 0), __extension__ (
{ if (input_size >= 1) ; else __assert_fail ("input_size >= 1"
, "ccv_cnnp_model_addons.c", 4113, __extension__ __PRETTY_FUNCTION__
); }));
4114 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 4114, __extension__ __PRETTY_FUNCTION__
); }));
4115 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
4116 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4117 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
4118 {
4119 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {0};
4120 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4121 ccv_nnc_tensor_get_stride(output_params.dim, stride);
4122 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
4123 } else {
4124 int old_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
4125 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4126 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], old_ofs, old_stride);
4127 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, to, old_ofs, old_stride, output_params, 0);
4128 }
4129 ccv_nnc_cmd_t cmd = ccv_nnc_cmd(CCV_NNC_CUSTOM_FORWARD, (ccv_nnc_cmd_vtab_t*)&ccv_cnnp_debug_exec_isa, (ccv_nnc_cmd_param_t){}, 0);
4130 cmd.data = self;
4131 ccv_nnc_graph_exec_symbol_t make_debug = ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, input_size, outputs, 1, "debug");
4132 // Disable any optimizations.
4133 ccv_nnc_graph_exec_symbol_set_flags(graph, make_debug, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
4134}
4135
4136static void _ccv_cnnp_debug_deinit(ccv_cnnp_model_t* const super)
4137{
4138 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
4139 if (self->debug_deinit && self->debug_context)
4140 self->debug_deinit(self->debug_context);
4141}
4142
4143static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context);
4144
4145static const ccv_cnnp_model_vtab_t ccv_cnnp_debug_isa = {
4146 .build = _ccv_cnnp_debug_build,
4147 .deinit = _ccv_cnnp_debug_deinit,
4148 .copy = _ccv_cnnp_debug_copy,
4149};
4150
4151ccv_cnnp_model_t* ccv_cnnp_debug(ccv_cnnp_model_debug_f func, void* const context, ccv_cnnp_model_debug_context_deinit_f deinit, ccv_cnnp_model_debug_context_copy_f copy, const char* const name)
4152{
4153 ccv_cnnp_model_debug_t* const model_debug = (ccv_cnnp_model_debug_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_debug_t));
4154 model_debug->super.isa = &ccv_cnnp_debug_isa;
4155 model_debug->super.input_size = 0;
4156 model_debug->super.outputs = &model_debug->output;
4157 model_debug->super.output_size = 1;
4158 model_debug->debugger = func;
4159 model_debug->debug_context = context;
4160 model_debug->debug_deinit = deinit;
4161 model_debug->debug_copy = copy;
4162 ccv_cnnp_model_copy_name(&model_debug->super, name);
4163 return (ccv_cnnp_model_t*)model_debug;
4164}
4165
4166static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context)
4167{
4168 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
4169 void* debug_context = self->debug_context;
4170 if (self->debug_copy && self->debug_context)
4171 debug_context = self->debug_copy(self->debug_context);
4172 return ccv_cnnp_debug(self->debugger, debug_context, self->debug_deinit, self->debug_copy, self->super.name);
4173}