Bug Summary

File:nnc/ccv_cnnp_model_addons.c
Warning:line 1147, 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-11-13-171041-289192-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 int dim[CCV_NNC_MAX_DIM_ALLOC(12)];
581 memcpy(dim, self->dim, sizeof(dim));
582 int i, auto_idx = -1;
583 size_t known = 1;
584 const size_t tensor_count = ccv_nnc_tensor_count(params);
585 for (i = 0; i < CCV_NNC_MAX_DIM_ALLOC(12) && dim[i]; i++)
586 if (dim[i] == -1)
587 auto_idx = i;
588 else
589 known *= dim[i];
590 if (auto_idx >= 0)
591 {
592 assert(known > 0 && tensor_count % known == 0)((void) sizeof ((known > 0 && tensor_count % known
== 0) ? 1 : 0), __extension__ ({ if (known > 0 &&
tensor_count % known == 0) ; else __assert_fail ("known > 0 && tensor_count % known == 0"
, "ccv_cnnp_model_addons.c", 592, __extension__ __PRETTY_FUNCTION__
); }));
593 dim[auto_idx] = tensor_count / known;
594 }
595 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
596 {
597 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);
598 int i;
599 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && params.dim[i] > 0; i++)
600 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);
601 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
602 }
603 assert(ccv_nnc_dimension_count(dim) <= ccv_nnc_tensor_count(params))((void) sizeof ((ccv_nnc_dimension_count(dim) <= ccv_nnc_tensor_count
(params)) ? 1 : 0), __extension__ ({ if (ccv_nnc_dimension_count
(dim) <= ccv_nnc_tensor_count(params)) ; else __assert_fail
("ccv_nnc_dimension_count(dim) <= ccv_nnc_tensor_count(params)"
, "ccv_cnnp_model_addons.c", 603, __extension__ __PRETTY_FUNCTION__
); }));
604 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
605 int stride_from_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
606 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
607 {
608 memcpy(params.dim, dim, sizeof(params.dim));
609 int* stride;
610 if (self->stride[0] == 0)
611 {
612 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
613 stride = stride_from_dim;
614 } else
615 stride = self->stride;
616 if (self->format > 0)
617 params.format = self->format;
618 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
619 } else {
620 // Otherwise, we need to check if it is permute. For permute, we cannot do alias directly.
621 // We need to first materialize the permute and then run reshape on top of it, otherwise it will be wrong.
622 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
623 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
624 // We identify permute by checking if the stride is not in descending order.
625 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
626 const int nd = ccv_nnc_tensor_nd(params.dim);
627 const int new_nd = ccv_nnc_tensor_nd(dim);
628 int i, no_permute = 1;
629 // If the new dim has different nd, or we actually have a stride, we need to check if it is no permute or not.
630 if (new_nd != nd || (self->stride[0] != 0 && memcmp(self->stride, old_stride, sizeof(self->stride))))
631 for (i = 1; no_permute && i < nd; i++)
632 if (old_stride[i - 1] < old_stride[i])
633 no_permute = 0;
634 if (no_permute)
635 { // Just straightforward reshape if there is no no permute.
636 memcpy(params.dim, dim, sizeof(params.dim));
637 int* stride;
638 if (self->stride[0] == 0)
639 {
640 if (new_nd != nd) // Cannot use old stride.
641 {
642 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
643 stride = stride_from_dim;
644 } else
645 stride = old_stride;
646 } else
647 stride = self->stride;
648 if (self->format > 0)
649 params.format = self->format;
650 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
651 } else {
652 // Otherwise, we first do format transform to plain tensor and then do reshape.
653 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, params, 0);
654 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");
655 memcpy(params.dim, dim, sizeof(params.dim));
656 int* stride;
657 if (self->stride[0] == 0)
658 {
659 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
660 stride = stride_from_dim;
661 } else
662 stride = self->stride;
663 if (self->format > 0)
664 params.format = self->format;
665 // And then we create alias against the permuted one.
666 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, self->ofs, stride, params, 0);
667 }
668 }
669}
670
671static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context);
672
673static const ccv_cnnp_model_vtab_t ccv_cnnp_reshape_isa = {
674 .build = _ccv_cnnp_reshape_build,
675 .copy = _ccv_cnnp_reshape_copy,
676};
677
678ccv_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)
679{
680 ccv_cnnp_model_reshape_t* const model_reshape = (ccv_cnnp_model_reshape_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reshape_t));
681 model_reshape->super.isa = &ccv_cnnp_reshape_isa;
682 model_reshape->super.input_size = 1;
683 model_reshape->super.outputs = &model_reshape->output;
684 model_reshape->super.output_size = 1;
685 ccv_cnnp_model_copy_name(&model_reshape->super, name);
686 model_reshape->format = format;
687 memcpy(model_reshape->dim, dim, sizeof(model_reshape->dim));
688 memcpy(model_reshape->ofs, ofs, sizeof(model_reshape->ofs));
689 if (stride[0] != 0)
690 memcpy(model_reshape->stride, stride, sizeof(model_reshape->stride));
691 return (ccv_cnnp_model_t*)model_reshape;
692}
693
694static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context)
695{
696 const ccv_cnnp_model_reshape_t* const self = (const ccv_cnnp_model_reshape_t*)super;
697 return ccv_cnnp_reshape(self->format, self->dim, self->ofs, self->stride, self->super.name);
698}
699
700typedef struct {
701 ccv_cnnp_model_t super;
702 ccv_nnc_tensor_symbol_t output;
703 int type;
704 int begin[CCV_NNC_MAX_DIM_ALLOC(12)];
705 int end[CCV_NNC_MAX_DIM_ALLOC(12)];
706} ccv_cnnp_model_pad_t;
707
708static 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)
709{
710 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"
, 710, __extension__ __PRETTY_FUNCTION__); }));
711 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", 711, __extension__ __PRETTY_FUNCTION__
); }));
712 ccv_cnnp_model_pad_t* const self = (ccv_cnnp_model_pad_t*)super;
713 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);
714 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
715 const int nd = ccv_nnc_tensor_nd(input_params.dim);
716 ccv_nnc_tensor_param_t params = input_params;
717 int i;
718 for (i = 0 ; i < nd; i++)
719 params.dim[i] += self->begin[i] + self->end[i];
720 const ccv_nnc_tensor_symbol_t padded = ccv_nnc_tensor_symbol_new(graph, params, 0);
721 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);
722 memcpy(pad.info.size.dim, self->begin, sizeof(pad.info.size.dim));
723 memcpy(pad.info.pad.end, self->end, sizeof(pad.info.pad.end));
724 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");
725 outputs[0] = padded;
726}
727
728static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context);
729
730static const ccv_cnnp_model_vtab_t ccv_cnnp_pad_isa = {
731 .build = _ccv_cnnp_pad_build,
732 .copy = _ccv_cnnp_pad_copy,
733};
734
735ccv_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)
736{
737 ccv_cnnp_model_pad_t* const model_pad = (ccv_cnnp_model_pad_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pad_t));
738 model_pad->super.isa = &ccv_cnnp_pad_isa;
739 model_pad->super.input_size = 1;
740 model_pad->super.outputs = &model_pad->output;
741 model_pad->super.output_size = 1;
742 ccv_cnnp_model_copy_name(&model_pad->super, name);
743 model_pad->type = type;
744 memcpy(model_pad->begin, begin, sizeof(model_pad->begin));
745 memcpy(model_pad->end, end, sizeof(model_pad->end));
746 return (ccv_cnnp_model_t*)model_pad;
747}
748
749static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context)
750{
751 const ccv_cnnp_model_pad_t* const self = (const ccv_cnnp_model_pad_t*)super;
752 return ccv_cnnp_pad(self->type, self->begin, self->end, self->super.name);
753}
754
755typedef struct {
756 ccv_cnnp_model_t super;
757 ccv_nnc_tensor_symbol_t output;
758} ccv_cnnp_model_identity_t;
759
760static 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)
761{
762 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"
, 762, __extension__ __PRETTY_FUNCTION__); }));
763 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", 763, __extension__ __PRETTY_FUNCTION__
); }));
764 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);
765 outputs[0] = inputs[0];
766}
767
768static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context);
769
770static const ccv_cnnp_model_vtab_t ccv_cnnp_identity_isa = {
771 .build = _ccv_cnnp_identity_build,
772 .copy = _ccv_cnnp_identity_copy,
773};
774
775ccv_cnnp_model_t* ccv_cnnp_identity(const char* const name)
776{
777 ccv_cnnp_model_identity_t* const model_identity = (ccv_cnnp_model_identity_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_identity_t));
778 model_identity->super.isa = &ccv_cnnp_identity_isa;
779 model_identity->super.input_size = 1;
780 model_identity->super.outputs = &model_identity->output;
781 model_identity->super.output_size = 1;
782 ccv_cnnp_model_copy_name(&model_identity->super, name);
783 return (ccv_cnnp_model_t*)model_identity;
784}
785
786static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context)
787{
788 const ccv_cnnp_model_identity_t* const self = (const ccv_cnnp_model_identity_t*)super;
789 return ccv_cnnp_identity(self->super.name);
790}
791
792typedef struct {
793 ccv_cnnp_model_t super;
794 ccv_nnc_tensor_symbol_t output;
795 int index[CCV_NNC_MAX_DIM_ALLOC(12)];
796} ccv_cnnp_model_permute_t;
797
798static 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)
799{
800 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"
, 800, __extension__ __PRETTY_FUNCTION__); }));
801 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", 801, __extension__ __PRETTY_FUNCTION__
); }));
802 ccv_cnnp_model_permute_t* const self = (ccv_cnnp_model_permute_t*)super;
803 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);
804 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
805 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
806 const int nd = ccv_nnc_tensor_nd(params.dim);
807 int input_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
808 memcpy(input_dim, params.dim, sizeof(params.dim));
809 int input_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
810 int output_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
811 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If it is not an alias. Find stride and permute.
812 {
813 ccv_nnc_tensor_get_stride(input_dim, input_stride);
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 }
822 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ccv_nnc_no_ofs, output_stride, params, 0);
823 } else {
824 // if it is an alias, we can get the stride from it and use that.
825 int input_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
826 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], input_ofs, input_stride);
827 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", 827, __extension__ __PRETTY_FUNCTION__
); }));
828 int output_ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
829 int i;
830 for (i = 0; i < nd; i++)
831 {
832 const int idx = self->index[i];
833 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"
, 833, __extension__ __PRETTY_FUNCTION__); }));
834 params.dim[i] = input_dim[idx];
835 output_stride[i] = input_stride[idx];
836 output_ofs[i] = input_ofs[idx];
837 }
838 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], output_ofs, output_stride, params, 0);
839 }
840}
841
842static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context);
843
844static const ccv_cnnp_model_vtab_t ccv_cnnp_permute_isa = {
845 .build = _ccv_cnnp_permute_build,
846 .copy = _ccv_cnnp_permute_copy,
847};
848
849ccv_cnnp_model_t* ccv_cnnp_permute(const int index[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
850{
851 ccv_cnnp_model_permute_t* const model_permute = (ccv_cnnp_model_permute_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_permute_t));
852 model_permute->super.isa = &ccv_cnnp_permute_isa;
853 model_permute->super.input_size = 1;
854 model_permute->super.outputs = &model_permute->output;
855 model_permute->super.output_size = 1;
856 ccv_cnnp_model_copy_name(&model_permute->super, name);
857 memcpy(model_permute->index, index, sizeof(model_permute->index));
858 return (ccv_cnnp_model_t*)model_permute;
859}
860
861static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context)
862{
863 const ccv_cnnp_model_permute_t* const self = (const ccv_cnnp_model_permute_t*)super;
864 return ccv_cnnp_permute(self->index, self->super.name);
865}
866
867typedef struct {
868 ccv_cnnp_model_t super;
869 int index;
870 ccv_nnc_tensor_symbol_t output;
871} ccv_cnnp_model_extract_t;
872
873static 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)
874{
875 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", 875, __extension__ __PRETTY_FUNCTION__
); }));
876 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
877 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);
878 outputs[0] = inputs[self->index];
879}
880
881static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const self, void* const context);
882
883static const ccv_cnnp_model_vtab_t ccv_cnnp_extract_isa = {
884 .build = _ccv_cnnp_extract_build,
885 .copy = _ccv_cnnp_extract_copy,
886};
887
888ccv_cnnp_model_t* ccv_cnnp_extract(const int index, const char* const name)
889{
890 ccv_cnnp_model_extract_t* const model_extract = (ccv_cnnp_model_extract_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_extract_t));
891 model_extract->index = index;
892 model_extract->super.isa = &ccv_cnnp_extract_isa;
893 model_extract->super.input_size = 0;
894 model_extract->super.outputs = &model_extract->output;
895 model_extract->super.output_size = 1;
896 ccv_cnnp_model_copy_name(&model_extract->super, name);
897 return (ccv_cnnp_model_t*)model_extract;
898}
899
900static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const super, void* const context)
901{
902 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
903 return ccv_cnnp_extract(self->index, self->super.name);
904}
905
906typedef struct {
907 ccv_cnnp_model_t super;
908 ccv_nnc_tensor_symbol_t output;
909} ccv_cnnp_model_flatten_t;
910
911static 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)
912{
913 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);
914 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"
, 914, __extension__ __PRETTY_FUNCTION__); }));
915 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", 915, __extension__ __PRETTY_FUNCTION__
); }));
916 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
917 ccv_nnc_tensor_param_t output_params = params;
918 memset(output_params.dim, 0, sizeof(output_params.dim));
919 output_params.dim[0] = ccv_nnc_tensor_get_n(params);
920 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", 920, __extension__ __PRETTY_FUNCTION__
); }));
921 output_params.dim[1] = ccv_nnc_tensor_count(params) / output_params.dim[0];
922 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
923 ccv_nnc_tensor_get_stride(output_params.dim, stride);
924 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], DIM_ALLOC()(int [(12)]){}, stride, output_params, 0);
925}
926
927static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context);
928
929static const ccv_cnnp_model_vtab_t ccv_cnnp_flatten_isa = {
930 .build = _ccv_cnnp_flatten_build,
931 .copy = _ccv_cnnp_flatten_copy,
932};
933
934ccv_cnnp_model_t* ccv_cnnp_flatten(const char* const name)
935{
936 ccv_cnnp_model_flatten_t* const model_flatten = (ccv_cnnp_model_flatten_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_flatten_t));
937 model_flatten->super.isa = &ccv_cnnp_flatten_isa;
938 model_flatten->super.input_size = 1;
939 model_flatten->super.outputs = &model_flatten->output;
940 model_flatten->super.output_size = 1;
941 ccv_cnnp_model_copy_name(&model_flatten->super, name);
942 return (ccv_cnnp_model_t*)model_flatten;
943}
944
945static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context)
946{
947 return ccv_cnnp_flatten(self->name);
948}
949
950// MARK - Batch Norm Layer
951
952typedef struct {
953 ccv_cnnp_model_t super;
954 ccv_nnc_tensor_symbol_t output;
955 ccv_nnc_tensor_symbol_t bias;
956 ccv_nnc_tensor_symbol_t scale;
957 ccv_nnc_graph_exec_symbol_t batch_norm;
958 ccv_nnc_cmd_param_t params;
959 ccv_array_t* zero_inits;
960 ccv_array_t* retainables;
961} ccv_cnnp_model_batch_norm_t;
962
963static 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)
964{
965 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"
, 965, __extension__ __PRETTY_FUNCTION__); }));
966 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", 966, __extension__ __PRETTY_FUNCTION__
); }));
967 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
968 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);
969 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
970 const int nd = ccv_nnc_tensor_nd(params.dim);
971 ccv_nnc_tensor_param_t bias_params = params;
972 memset(bias_params.dim, 0, sizeof(bias_params.dim));
973 // If the accuracy is not enough, bump it to 32-bit floating point.
974 if (bias_params.datatype != CCV_32F && bias_params.datatype != CCV_64F)
975 bias_params.datatype = CCV_32F;
976 bias_params.dim[0] = nd > 1 ? ccv_nnc_tensor_get_c(params) : params.dim[0];
977 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, params, 0);
978 // Both scale and bias are shared between if this model is reused.
979 if (!self->scale.graph)
980 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
981 if (!self->bias.graph)
982 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
983 const ccv_nnc_tensor_symbol_t mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "mean");
984 const ccv_nnc_tensor_symbol_t var = ccv_nnc_tensor_symbol_new(graph, bias_params, "var");
985 // Otherwise, notice mean, var, saved_mean, saved_inv_std are not reused.
986 if (!self->zero_inits)
987 self->zero_inits = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
988 ccv_array_push(self->zero_inits, &mean);
989 ccv_array_push(self->zero_inits, &var);
990 const ccv_nnc_tensor_symbol_t out_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_mean");
991 const ccv_nnc_tensor_symbol_t out_var = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_var");
992 if (!self->retainables)
993 self->retainables = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
994 ccv_array_push(self->retainables, &out_mean);
995 ccv_array_push(self->retainables, &out_var);
996 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_mean");
997 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_inv_std");
998 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
999 ccv_nnc_cmd_param_t batch_norm = self->params;
1000 batch_norm.bnorm.count = hw >= 0 ? CCV_NNC_MAX_DIM(2) + 1 : 1;
1001 int i;
1002 batch_norm.bnorm.axis[0] = (params.format == CCV_TENSOR_FORMAT_CHWN) ? 3 : 0;
1003 if (hw >= 0)
1004 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1005 batch_norm.bnorm.axis[i + 1] = i + hw;
1006 self->params = batch_norm;
1007 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");
1008 outputs[0] = output;
1009}
1010
1011static 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)
1012{
1013 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1014 if (self->scale.graph)
1015 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);
1016 if (self->bias.graph)
1017 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);
1018 int i;
1019 if (self->zero_inits)
1020 for (i = 0; i < self->zero_inits->rnum; i++)
1021 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))));
1022}
1023
1024static 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)
1025{
1026 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1027 if (self->scale.graph)
1028 add_to_array(parameters, self->scale, is_trainable);
1029 if (self->bias.graph)
1030 add_to_array(parameters, self->bias, is_trainable);
1031}
1032
1033static 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)
1034{
1035 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1036 int i;
1037 if (self->retainables)
1038 for (i = 0; i < self->retainables->rnum; i++)
1039 {
1040 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)));
1041 add_to_array(outputs, symbol, 0);
1042 }
1043}
1044
1045static 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)
1046{
1047 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1048 if (self->batch_norm.graph)
1049 {
1050 self->params.bnorm.is_test = is_test;
1051 updater(context, self->batch_norm, ccv_nnc_cmd(CCV_NNC_BATCH_NORM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
1052 }
1053}
1054
1055static void _ccv_cnnp_batch_norm_deinit(ccv_cnnp_model_t* const super)
1056{
1057 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1058 if (self->zero_inits)
1059 ccv_array_free(self->zero_inits);
1060 if (self->retainables)
1061 ccv_array_free(self->retainables);
1062}
1063
1064static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
1065
1066static const ccv_cnnp_model_vtab_t ccv_cnnp_batch_norm_isa = {
1067 .build = _ccv_cnnp_batch_norm_build,
1068 .init_states = _ccv_cnnp_batch_norm_init_states,
1069 .add_to_parameter = _ccv_cnnp_batch_norm_add_to_parameter,
1070 .add_to_output = _ccv_cnnp_batch_norm_add_to_output,
1071 .copy = _ccv_cnnp_batch_norm_copy,
1072 .set_is_test = _ccv_cnnp_batch_norm_set_is_test,
1073 .deinit = _ccv_cnnp_batch_norm_deinit,
1074};
1075
1076ccv_cnnp_model_t* ccv_cnnp_batch_norm(const float momentum, const float epsilon, const int is_trainable, const char* const name)
1077{
1078 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));
1079 model_batch_norm->super.isa = &ccv_cnnp_batch_norm_isa;
1080 model_batch_norm->super.input_size = 1;
1081 model_batch_norm->super.outputs = &model_batch_norm->output;
1082 model_batch_norm->super.output_size = 1;
1083 model_batch_norm->super.is_trainable = is_trainable;
1084 ccv_cnnp_model_copy_name(&model_batch_norm->super, name);
1085 model_batch_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
1086 model_batch_norm->scale.graph = 0;
1087 model_batch_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1088 model_batch_norm->bias.graph = 0;
1089 model_batch_norm->params.bnorm.momentum = momentum;
1090 model_batch_norm->params.bnorm.epsilon = epsilon;
1091 return (ccv_cnnp_model_t*)model_batch_norm;
1092}
1093
1094static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
1095{
1096 const ccv_cnnp_model_batch_norm_t* const self = (const ccv_cnnp_model_batch_norm_t*)super;
1097 return ccv_cnnp_batch_norm(self->params.bnorm.momentum, self->params.bnorm.epsilon, self->super.is_trainable, self->super.name);
1098}
1099
1100// MARK - Convolution Layer
1101
1102typedef struct {
1103 ccv_cnnp_model_t super;
1104 ccv_nnc_tensor_symbol_t output;
1105 ccv_nnc_tensor_symbol_t weights;
1106 ccv_nnc_tensor_symbol_t bias;
1107 int groups;
1108 int filters;
1109 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1110 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1111 int no_bias;
1112 int format;
1113 ccv_nnc_hint_t hint;
1114} ccv_cnnp_model_convolution_t;
1115
1116static 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)
1117{
1118 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1119 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
→
1120 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"
, 1120, __extension__ __PRETTY_FUNCTION__); }));
4
←
Assuming 'input_size' is equal to 1
→
5
←
Taking true branch
→
1121 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", 1121, __extension__ __PRETTY_FUNCTION__
); }));
6
←
Assuming 'output_size' is equal to 1
→
7
←
Taking true branch
→
1122 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1123 int i;
1124 const int k_nd = ccv_nnc_tensor_nd(self->kdim);
1125 const int nd = k_nd + 2;
1126 ccv_nnc_tensor_param_t weights_params = params;
1127 if (self->format)
8
←
Assuming field 'format' is 0
→
9
←
Taking false branch
→
1128 weights_params.format = self->format;
1129 ccv_nnc_tensor_set_n(&weights_params, self->filters);
1130 const int a_nd = ccv_nnc_tensor_nd(params.dim);
1131 int c;
10
←
'c' declared without an initial value
→
1132 switch (params.format)
11
←
'Default' branch taken. Execution continues on line 1147
→
1133 {
1134 case CCV_TENSOR_FORMAT_NHWC:
1135 c = params.dim[a_nd - 1];
1136 break;
1137 case CCV_TENSOR_FORMAT_NCHW:
1138 if (a_nd == k_nd + 1)
1139 c = params.dim[0];
1140 else
1141 c = params.dim[a_nd <= 1 ? 0 : 1];
1142 break;
1143 case CCV_TENSOR_FORMAT_CHWN:
1144 c = params.dim[0];
1145 break;
1146 }
1147 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", 1147, __extension__ __PRETTY_FUNCTION__
); }));
12
←
The left operand of '%' is a garbage value
1148 ccv_nnc_tensor_set_c(&weights_params, nd, c / self->groups);
1149 int hw = -1;
1150 if (weights_params.format == CCV_TENSOR_FORMAT_NHWC || weights_params.format == CCV_TENSOR_FORMAT_CHWN)
1151 hw = 1;
1152 else if (weights_params.format == CCV_TENSOR_FORMAT_NCHW)
1153 hw = 2;
1154 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1154, __extension__ __PRETTY_FUNCTION__); }));
1155 for (i = 0; i < k_nd; i++)
1156 weights_params.dim[i + hw] = self->kdim[i];
1157 if (!self->weights.graph)
1158 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1159 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"
, 1159, __extension__ __PRETTY_FUNCTION__); }));
1160 ccv_nnc_tensor_param_t bias_params = params;
1161 if (self->format)
1162 bias_params.format = self->format;
1163 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1164 bias_params.dim[0] = self->filters;
1165 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);
1166 for (i = 0; i < k_nd; i++)
1167 cmd.info.size.dim[i] = self->kdim[i];
1168 cmd.info.size.dim[k_nd] = c;
1169 memcpy(cmd.info.convolution.dilation, self->dilation, sizeof(self->dilation));
1170 ccv_nnc_tensor_param_t output_params;
1171 // Dilate weight size based on the dilation factor.
1172 for (i = 0; i < k_nd; i++)
1173 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;
1174 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1175 params,
1176 weights_params,
1177 bias_params,
1178 }, 3, self->hint, &output_params, 1);
1179 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1180 ccv_nnc_graph_exec_symbol_t convolution;
1181 if (self->no_bias)
1182 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");
1183 else {
1184 if (!self->bias.graph)
1185 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1186 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");
1187 }
1188 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution, self->hint);
1189 outputs[0] = output;
1190}
1191
1192static 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)
1193{
1194 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1195 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1196 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
; });
1197 const int count = ccv_nnc_tensor_count(weight_params);
1198 const float std = sqrtf(2) / sqrtf(count / n);
1199 const float bound = sqrtf(3) * std;
1200 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);
1201 if (self->bias.graph)
1202 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);
1203}
1204
1205static 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)
1206{
1207 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1208 add_to_array(parameters, self->weights, is_trainable);
1209 if (self->bias.graph)
1210 add_to_array(parameters, self->bias, is_trainable);
1211}
1212
1213static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context);
1214
1215static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_isa = {
1216 .build = _ccv_cnnp_convolution_build,
1217 .init_states = _ccv_cnnp_convolution_init_states,
1218 .add_to_parameter = _ccv_cnnp_convolution_add_to_parameter,
1219 .copy = _ccv_cnnp_convolution_copy,
1220};
1221
1222ccv_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)
1223{
1224 ccv_cnnp_model_convolution_t* const model_convolution = (ccv_cnnp_model_convolution_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_convolution_t));
1225 model_convolution->super.isa = &ccv_cnnp_convolution_isa;
1226 model_convolution->super.input_size = 1;
1227 model_convolution->super.outputs = &model_convolution->output;
1228 model_convolution->super.output_size = 1;
1229 model_convolution->super.is_trainable = is_trainable;
1230 ccv_cnnp_model_copy_name(&model_convolution->super, name);
1231 model_convolution->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1232 model_convolution->weights.graph = 0;
1233 model_convolution->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1234 model_convolution->bias.graph = 0;
1235 model_convolution->groups = groups;
1236 model_convolution->filters = filters;
1237 memcpy(model_convolution->kdim, kdim, sizeof(model_convolution->kdim));
1238 memcpy(model_convolution->dilation, dilation, sizeof(model_convolution->dilation));
1239 model_convolution->no_bias = no_bias;
1240 model_convolution->hint = hint;
1241 model_convolution->format = format;
1242 return (ccv_cnnp_model_t*)model_convolution;
1243}
1244
1245static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context)
1246{
1247 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1248 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);
1249}
1250
1251// MARK - Convolution Transpose Layer
1252
1253typedef struct {
1254 ccv_cnnp_model_t super;
1255 ccv_nnc_tensor_symbol_t output;
1256 ccv_nnc_tensor_symbol_t weights;
1257 ccv_nnc_tensor_symbol_t bias;
1258 int groups;
1259 int filters;
1260 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1261 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1262 int output_padding;
1263 int no_bias;
1264 int format;
1265 ccv_nnc_hint_t hint;
1266} ccv_cnnp_model_convolution_transpose_t;
1267
1268static 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)
1269{
1270 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1271 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);
1272 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"
, 1272, __extension__ __PRETTY_FUNCTION__); }));
1273 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", 1273, __extension__ __PRETTY_FUNCTION__
); }));
1274 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1275 int i;
1276 const int nd = CCV_NNC_MAX_DIM(2) + 2;
1277 ccv_nnc_tensor_param_t weights_params = params;
1278 if (self->format)
1279 weights_params.format = self->format;
1280 const int c = ccv_nnc_tensor_get_c(params);
1281 ccv_nnc_tensor_set_n(&weights_params, c);
1282 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", 1282, __extension__ __PRETTY_FUNCTION__
); }));
1283 ccv_nnc_tensor_set_c(&weights_params, nd, self->filters / self->groups);
1284 const int hw = ccv_nnc_tensor_hw(weights_params, nd, CCV_NNC_MAX_DIM(2));
1285 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1285, __extension__ __PRETTY_FUNCTION__); }));
1286 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1287 weights_params.dim[i + hw] = self->kdim[i];
1288 if (!self->weights.graph)
1289 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1290 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"
, 1290, __extension__ __PRETTY_FUNCTION__); }));
1291 ccv_nnc_tensor_param_t bias_params = params;
1292 if (self->format)
1293 bias_params.format = self->format;
1294 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1295 bias_params.dim[0] = self->filters;
1296 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);
1297 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1298 cmd.info.size.dim[i] = self->kdim[i];
1299 cmd.info.size.dim[CCV_NNC_MAX_DIM(2)] = c;
1300 memcpy(cmd.info.convolution_transpose.dilation, self->dilation, sizeof(self->dilation));
1301 ccv_nnc_tensor_param_t output_params;
1302 // Dilate weight size based on the dilation factor.
1303 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1304 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;
1305 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1306 params,
1307 weights_params,
1308 bias_params,
1309 }, 3, self->hint, &output_params, 1);
1310 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1311 ccv_nnc_graph_exec_symbol_t convolution_transpose;
1312 if (self->no_bias)
1313 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");
1314 else {
1315 if (!self->bias.graph)
1316 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1317 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");
1318 }
1319 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution_transpose, self->hint);
1320 outputs[0] = output;
1321}
1322
1323static 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)
1324{
1325 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1326 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1327 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
; });
1328 const int count = ccv_nnc_tensor_count(weight_params);
1329 const float std = sqrtf(2) / sqrtf(count / n);
1330 const float bound = sqrtf(3) * std;
1331 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);
1332 if (self->bias.graph)
1333 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);
1334}
1335
1336static 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)
1337{
1338 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1339 add_to_array(parameters, self->weights, is_trainable);
1340 if (self->bias.graph)
1341 add_to_array(parameters, self->bias, is_trainable);
1342}
1343
1344static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
1345
1346static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_transpose_isa = {
1347 .build = _ccv_cnnp_convolution_transpose_build,
1348 .init_states = _ccv_cnnp_convolution_transpose_init_states,
1349 .add_to_parameter = _ccv_cnnp_convolution_transpose_add_to_parameter,
1350 .copy = _ccv_cnnp_convolution_transpose_copy,
1351};
1352
1353ccv_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)
1354{
1355 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));
1356 model_convolution_transpose->super.isa = &ccv_cnnp_convolution_transpose_isa;
1357 model_convolution_transpose->super.input_size = 1;
1358 model_convolution_transpose->super.outputs = &model_convolution_transpose->output;
1359 model_convolution_transpose->super.output_size = 1;
1360 model_convolution_transpose->super.is_trainable = is_trainable;
1361 ccv_cnnp_model_copy_name(&model_convolution_transpose->super, name);
1362 model_convolution_transpose->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1363 model_convolution_transpose->weights.graph = 0;
1364 model_convolution_transpose->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1365 model_convolution_transpose->bias.graph = 0;
1366 model_convolution_transpose->groups = groups;
1367 model_convolution_transpose->filters = filters;
1368 memcpy(model_convolution_transpose->kdim, kdim, sizeof(model_convolution_transpose->kdim));
1369 memcpy(model_convolution_transpose->dilation, dilation, sizeof(model_convolution_transpose->dilation));
1370 model_convolution_transpose->output_padding = output_padding;
1371 model_convolution_transpose->no_bias = no_bias;
1372 model_convolution_transpose->hint = hint;
1373 model_convolution_transpose->format = format;
1374 return (ccv_cnnp_model_t*)model_convolution_transpose;
1375}
1376
1377static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
1378{
1379 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1380 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);
1381}
1382
1383// MARK - Dense Layer
1384
1385typedef struct {
1386 ccv_cnnp_model_t super;
1387 ccv_nnc_tensor_symbol_t output;
1388 ccv_nnc_tensor_symbol_t weights;
1389 ccv_nnc_tensor_symbol_t bias;
1390 int count;
1391 int no_bias;
1392 int flags;
1393} ccv_cnnp_model_dense_t;
1394
1395static 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)
1396{
1397 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1398 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);
1399 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"
, 1399, __extension__ __PRETTY_FUNCTION__); }));
1400 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", 1400, __extension__ __PRETTY_FUNCTION__
); }));
1401 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1402 ccv_nnc_tensor_param_t weights_params = params;
1403 memset(weights_params.dim, 0, sizeof(weights_params.dim));
1404 weights_params.dim[0] = self->count;
1405 weights_params.dim[1] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
1406 if (!self->weights.graph)
1407 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1408 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"
, 1408, __extension__ __PRETTY_FUNCTION__); }));
1409 ccv_nnc_tensor_param_t bias_params = params;
1410 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1411 bias_params.dim[0] = self->count;
1412 ccv_nnc_cmd_t cmd = {0};
1413 cmd.cmd = CCV_NNC_GEMM_FORWARD;
1414 cmd.info.blas.a[0] = 1;
1415 cmd.info.blas.a[1] = 1;
1416 cmd.info.blas.transpose_b[0] = 0;
1417 cmd.info.blas.transpose_b[1] = 1;
1418 cmd.info.blas.flags = self->flags;
1419 ccv_nnc_tensor_param_t output_params;
1420 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1421 params,
1422 weights_params,
1423 bias_params,
1424 }, 3, ccv_nnc_no_hint, &output_params, 1);
1425 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1426 if (self->no_bias)
1427 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");
1428 else {
1429 if (!self->bias.graph)
1430 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1431 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");
1432 }
1433 outputs[0] = output;
1434}
1435
1436static 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)
1437{
1438 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1439 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1440 const int c = weight_params.dim[1];
1441 const float std = sqrtf(2) / sqrtf(c);
1442 const float bound = sqrtf(3) * std;
1443 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);
1444 if (self->bias.graph)
1445 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);
1446}
1447
1448static 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)
1449{
1450 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1451 add_to_array(parameters, self->weights, is_trainable);
1452 if (self->bias.graph)
1453 add_to_array(parameters, self->bias, is_trainable);
1454}
1455
1456static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
1457
1458static const ccv_cnnp_model_vtab_t ccv_cnnp_dense_isa = {
1459 .build = _ccv_cnnp_dense_build,
1460 .init_states = _ccv_cnnp_dense_init_states,
1461 .add_to_parameter = _ccv_cnnp_dense_add_to_parameter,
1462 .copy = _ccv_cnnp_dense_copy,
1463};
1464
1465ccv_cnnp_model_t* ccv_cnnp_dense(const int count, const int no_bias, const int flags, const int is_trainable, const char* const name)
1466{
1467 ccv_cnnp_model_dense_t* const model_dense = (ccv_cnnp_model_dense_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dense_t));
1468 model_dense->super.isa = &ccv_cnnp_dense_isa;
1469 model_dense->super.input_size = 1;
1470 model_dense->super.outputs = &model_dense->output;
1471 model_dense->super.output_size = 1;
1472 model_dense->super.is_trainable = is_trainable;
1473 ccv_cnnp_model_copy_name(&model_dense->super, name);
1474 model_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1475 model_dense->weights.graph = 0;
1476 model_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1477 model_dense->bias.graph = 0;
1478 model_dense->count = count;
1479 model_dense->no_bias = no_bias;
1480 model_dense->flags = flags;
1481 return (ccv_cnnp_model_t*)model_dense;
1482}
1483
1484static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
1485{
1486 const ccv_cnnp_model_dense_t* const self = (const ccv_cnnp_model_dense_t*)super;
1487 return ccv_cnnp_dense(self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
1488}
1489
1490// MARK - Pool Layers
1491
1492typedef struct {
1493 ccv_cnnp_model_t super;
1494 ccv_nnc_tensor_symbol_t output;
1495 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1496 ccv_nnc_hint_t hint;
1497} ccv_cnnp_model_pool_t;
1498
1499static 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)
1500{
1501 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1502 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);
1503 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"
, 1503, __extension__ __PRETTY_FUNCTION__); }));
1504 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", 1504, __extension__ __PRETTY_FUNCTION__
); }));
1505 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1506 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1507 ccv_nnc_cmd_t cmd;
1508 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1509 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);
1510 else
1511 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);
1512 ccv_nnc_tensor_param_t output_params;
1513 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1514 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1515 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");
1516 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1517 outputs[0] = pool_output;
1518}
1519
1520static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1521
1522static const ccv_cnnp_model_vtab_t ccv_cnnp_max_pool_isa = {
1523 .build = _ccv_cnnp_max_pool_build,
1524 .copy = _ccv_cnnp_max_pool_copy,
1525};
1526
1527ccv_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)
1528{
1529 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1530 model_pool->super.isa = &ccv_cnnp_max_pool_isa;
1531 model_pool->super.input_size = 1;
1532 model_pool->super.outputs = &model_pool->output;
1533 model_pool->super.output_size = 1;
1534 ccv_cnnp_model_copy_name(&model_pool->super, name);
1535 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1536 model_pool->hint = hint;
1537 return (ccv_cnnp_model_t*)model_pool;
1538}
1539
1540static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1541{
1542 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1543 return ccv_cnnp_max_pool(self->kdim, self->hint, self->super.name);
1544}
1545
1546static 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)
1547{
1548 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1549 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);
1550 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"
, 1550, __extension__ __PRETTY_FUNCTION__); }));
1551 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", 1551, __extension__ __PRETTY_FUNCTION__
); }));
1552 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1553 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1554 ccv_nnc_cmd_t cmd;
1555 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1556 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);
1557 else
1558 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);
1559 ccv_nnc_tensor_param_t output_params;
1560 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1561 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1562 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");
1563 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1564 outputs[0] = pool_output;
1565}
1566
1567static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1568
1569static const ccv_cnnp_model_vtab_t ccv_cnnp_average_pool_isa = {
1570 .build = _ccv_cnnp_average_pool_build,
1571 .copy = _ccv_cnnp_average_pool_copy,
1572};
1573
1574ccv_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)
1575{
1576 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1577 model_pool->super.isa = &ccv_cnnp_average_pool_isa;
1578 model_pool->super.input_size = 1;
1579 model_pool->super.outputs = &model_pool->output;
1580 model_pool->super.output_size = 1;
1581 ccv_cnnp_model_copy_name(&model_pool->super, name);
1582 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1583 model_pool->hint = hint;
1584 return (ccv_cnnp_model_t*)model_pool;
1585}
1586
1587static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1588{
1589 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1590 return ccv_cnnp_average_pool(self->kdim, self->hint, self->super.name);
1591}
1592
1593// MARK - RELU Layer
1594
1595typedef struct {
1596 ccv_cnnp_model_t super;
1597 ccv_nnc_tensor_symbol_t output;
1598} ccv_cnnp_model_relu_t;
1599
1600static 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)
1601{
1602 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);
1603 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"
, 1603, __extension__ __PRETTY_FUNCTION__); }));
1604 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", 1604, __extension__ __PRETTY_FUNCTION__
); }));
1605 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1606 ccv_nnc_tensor_param_t output_params;
1607 const ccv_nnc_cmd_t relu = CMD_RELU_FORWARD()ccv_nnc_cmd(CCV_NNC_RELU_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1608 ccv_nnc_hint_tensor_auto(relu, (ccv_nnc_tensor_param_t []){
1609 params,
1610 }, 1, ccv_nnc_no_hint, &output_params, 1);
1611 const ccv_nnc_tensor_symbol_t relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1612 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");
1613 outputs[0] = relu_output;
1614}
1615
1616static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1617
1618static const ccv_cnnp_model_vtab_t ccv_cnnp_relu_isa = {
1619 .build = _ccv_cnnp_relu_build,
1620 .copy = _ccv_cnnp_relu_copy,
1621};
1622
1623ccv_cnnp_model_t* ccv_cnnp_relu(const char* const name)
1624{
1625 ccv_cnnp_model_relu_t* const model_relu = (ccv_cnnp_model_relu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_relu_t));
1626 model_relu->super.isa = &ccv_cnnp_relu_isa;
1627 model_relu->super.input_size = 1;
1628 model_relu->super.outputs = &model_relu->output;
1629 model_relu->super.output_size = 1;
1630 ccv_cnnp_model_copy_name(&model_relu->super, name);
1631 return (ccv_cnnp_model_t*)model_relu;
1632}
1633
1634static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context)
1635{
1636 return ccv_cnnp_relu(self->name);
1637}
1638
1639// MARK - Sigmoid Layer
1640
1641typedef struct {
1642 ccv_cnnp_model_t super;
1643 ccv_nnc_tensor_symbol_t output;
1644} ccv_cnnp_model_sigmoid_t;
1645
1646static 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)
1647{
1648 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);
1649 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"
, 1649, __extension__ __PRETTY_FUNCTION__); }));
1650 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", 1650, __extension__ __PRETTY_FUNCTION__
); }));
1651 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1652 ccv_nnc_tensor_param_t output_params;
1653 const ccv_nnc_cmd_t sigmoid = CMD_SIGMOID_FORWARD()ccv_nnc_cmd(CCV_NNC_SIGMOID_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1654 ccv_nnc_hint_tensor_auto(sigmoid, (ccv_nnc_tensor_param_t []){
1655 params,
1656 }, 1, ccv_nnc_no_hint, &output_params, 1);
1657 const ccv_nnc_tensor_symbol_t sigmoid_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1658 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");
1659 outputs[0] = sigmoid_output;
1660}
1661
1662static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context);
1663
1664static const ccv_cnnp_model_vtab_t ccv_cnnp_sigmoid_isa = {
1665 .build = _ccv_cnnp_sigmoid_build,
1666 .copy = _ccv_cnnp_sigmoid_copy,
1667};
1668
1669ccv_cnnp_model_t* ccv_cnnp_sigmoid(const char* const name)
1670{
1671 ccv_cnnp_model_sigmoid_t* const model_sigmoid = (ccv_cnnp_model_sigmoid_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sigmoid_t));
1672 model_sigmoid->super.isa = &ccv_cnnp_sigmoid_isa;
1673 model_sigmoid->super.input_size = 1;
1674 model_sigmoid->super.outputs = &model_sigmoid->output;
1675 model_sigmoid->super.output_size = 1;
1676 ccv_cnnp_model_copy_name(&model_sigmoid->super, name);
1677 return (ccv_cnnp_model_t*)model_sigmoid;
1678}
1679
1680static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context)
1681{
1682 return ccv_cnnp_sigmoid(self->name);
1683}
1684
1685// MARK - Tanh Layer
1686
1687typedef struct {
1688 ccv_cnnp_model_t super;
1689 ccv_nnc_tensor_symbol_t output;
1690} ccv_cnnp_model_tanh_t;
1691
1692static 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)
1693{
1694 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);
1695 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"
, 1695, __extension__ __PRETTY_FUNCTION__); }));
1696 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", 1696, __extension__ __PRETTY_FUNCTION__
); }));
1697 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1698 ccv_nnc_tensor_param_t output_params;
1699 const ccv_nnc_cmd_t tanh = CMD_TANH_FORWARD()ccv_nnc_cmd(CCV_NNC_TANH_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1700 ccv_nnc_hint_tensor_auto(tanh, (ccv_nnc_tensor_param_t []){
1701 params,
1702 }, 1, ccv_nnc_no_hint, &output_params, 1);
1703 const ccv_nnc_tensor_symbol_t tanh_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1704 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");
1705 outputs[0] = tanh_output;
1706}
1707
1708static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context);
1709
1710static const ccv_cnnp_model_vtab_t ccv_cnnp_tanh_isa = {
1711 .build = _ccv_cnnp_tanh_build,
1712 .copy = _ccv_cnnp_tanh_copy,
1713};
1714
1715ccv_cnnp_model_t* ccv_cnnp_tanh(const char* const name)
1716{
1717 ccv_cnnp_model_tanh_t* const model_tanh = (ccv_cnnp_model_tanh_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_tanh_t));
1718 model_tanh->super.isa = &ccv_cnnp_tanh_isa;
1719 model_tanh->super.input_size = 1;
1720 model_tanh->super.outputs = &model_tanh->output;
1721 model_tanh->super.output_size = 1;
1722 ccv_cnnp_model_copy_name(&model_tanh->super, name);
1723 return (ccv_cnnp_model_t*)model_tanh;
1724}
1725
1726static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context)
1727{
1728 return ccv_cnnp_tanh(self->name);
1729}
1730
1731// MARK - Swish Layer
1732
1733typedef struct {
1734 ccv_cnnp_model_t super;
1735 ccv_nnc_tensor_symbol_t output;
1736} ccv_cnnp_model_swish_t;
1737
1738static 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)
1739{
1740 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);
1741 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"
, 1741, __extension__ __PRETTY_FUNCTION__); }));
1742 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", 1742, __extension__ __PRETTY_FUNCTION__
); }));
1743 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1744 ccv_nnc_tensor_param_t output_params;
1745 const ccv_nnc_cmd_t swish = CMD_SWISH_FORWARD()ccv_nnc_cmd(CCV_NNC_SWISH_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1746 ccv_nnc_hint_tensor_auto(swish, (ccv_nnc_tensor_param_t []){
1747 params,
1748 }, 1, ccv_nnc_no_hint, &output_params, 1);
1749 const ccv_nnc_tensor_symbol_t swish_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1750 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");
1751 outputs[0] = swish_output;
1752}
1753
1754static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context);
1755
1756static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_isa = {
1757 .build = _ccv_cnnp_swish_build,
1758 .copy = _ccv_cnnp_swish_copy,
1759};
1760
1761ccv_cnnp_model_t* ccv_cnnp_swish(const char* const name)
1762{
1763 ccv_cnnp_model_swish_t* const model_swish = (ccv_cnnp_model_swish_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swish_t));
1764 model_swish->super.isa = &ccv_cnnp_swish_isa;
1765 model_swish->super.input_size = 1;
1766 model_swish->super.outputs = &model_swish->output;
1767 model_swish->super.output_size = 1;
1768 ccv_cnnp_model_copy_name(&model_swish->super, name);
1769 return (ccv_cnnp_model_t*)model_swish;
1770}
1771
1772static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context)
1773{
1774 return ccv_cnnp_swish(self->name);
1775}
1776
1777// MARK - GELU Layer
1778
1779typedef struct {
1780 ccv_cnnp_model_t super;
1781 ccv_nnc_tensor_symbol_t output;
1782 int tanh;
1783} ccv_cnnp_model_gelu_t;
1784
1785static 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)
1786{
1787 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);
1788 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"
, 1788, __extension__ __PRETTY_FUNCTION__); }));
1789 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", 1789, __extension__ __PRETTY_FUNCTION__
); }));
1790 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1791 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1792 ccv_nnc_tensor_param_t output_params;
1793 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);
1794 ccv_nnc_hint_tensor_auto(gelu, (ccv_nnc_tensor_param_t []){
1795 params,
1796 }, 1, ccv_nnc_no_hint, &output_params, 1);
1797 const ccv_nnc_tensor_symbol_t gelu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1798 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");
1799 outputs[0] = gelu_output;
1800}
1801
1802static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const self, void* const context);
1803
1804static const ccv_cnnp_model_vtab_t ccv_cnnp_gelu_isa = {
1805 .build = _ccv_cnnp_gelu_build,
1806 .copy = _ccv_cnnp_gelu_copy,
1807};
1808
1809ccv_cnnp_model_t* ccv_cnnp_gelu(const int tanh, const char* const name)
1810{
1811 ccv_cnnp_model_gelu_t* const model_gelu = (ccv_cnnp_model_gelu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gelu_t));
1812 model_gelu->super.isa = &ccv_cnnp_gelu_isa;
1813 model_gelu->super.input_size = 1;
1814 model_gelu->super.outputs = &model_gelu->output;
1815 model_gelu->super.output_size = 1;
1816 model_gelu->tanh = tanh;
1817 ccv_cnnp_model_copy_name(&model_gelu->super, name);
1818 return (ccv_cnnp_model_t*)model_gelu;
1819}
1820
1821static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const super, void* const context)
1822{
1823 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1824 return ccv_cnnp_gelu(self->tanh, self->super.name);
1825}
1826
1827// MARK - Leaky ReLU Layer
1828
1829typedef struct {
1830 ccv_cnnp_model_t super;
1831 ccv_nnc_tensor_symbol_t output;
1832 float negative_slope;
1833} ccv_cnnp_model_leaky_relu_t;
1834
1835static 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)
1836{
1837 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);
1838 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"
, 1838, __extension__ __PRETTY_FUNCTION__); }));
1839 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", 1839, __extension__ __PRETTY_FUNCTION__
); }));
1840 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
1841 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1842 ccv_nnc_tensor_param_t output_params;
1843 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);
1844 ccv_nnc_hint_tensor_auto(leaky_relu, (ccv_nnc_tensor_param_t []){
1845 params,
1846 }, 1, ccv_nnc_no_hint, &output_params, 1);
1847 const ccv_nnc_tensor_symbol_t leaky_relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1848 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");
1849 outputs[0] = leaky_relu_output;
1850}
1851
1852static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1853
1854static const ccv_cnnp_model_vtab_t ccv_cnnp_leaky_relu_isa = {
1855 .build = _ccv_cnnp_leaky_relu_build,
1856 .copy = _ccv_cnnp_leaky_relu_copy,
1857};
1858
1859ccv_cnnp_model_t* ccv_cnnp_leaky_relu(const float negative_slope, const char* const name)
1860{
1861 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));
1862 model_leaky_relu->super.isa = &ccv_cnnp_leaky_relu_isa;
1863 model_leaky_relu->super.input_size = 1;
1864 model_leaky_relu->super.outputs = &model_leaky_relu->output;
1865 model_leaky_relu->super.output_size = 1;
1866 model_leaky_relu->negative_slope = negative_slope;
1867 ccv_cnnp_model_copy_name(&model_leaky_relu->super, name);
1868 return (ccv_cnnp_model_t*)model_leaky_relu;
1869}
1870
1871static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const super, void* const context)
1872{
1873 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
1874 return ccv_cnnp_leaky_relu(self->negative_slope, self->super.name);
1875}
1876
1877// MARK - Softmax Layer
1878
1879typedef struct {
1880 ccv_cnnp_model_t super;
1881 ccv_nnc_tensor_symbol_t output;
1882} ccv_cnnp_model_softmax_t;
1883
1884static 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)
1885{
1886 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);
1887 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"
, 1887, __extension__ __PRETTY_FUNCTION__); }));
1888 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", 1888, __extension__ __PRETTY_FUNCTION__
); }));
1889 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1890 ccv_nnc_tensor_param_t output_params;
1891 const ccv_nnc_cmd_t softmax = CMD_SOFTMAX_FORWARD()ccv_nnc_cmd(CCV_NNC_SOFTMAX_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1892 ccv_nnc_hint_tensor_auto(softmax, (ccv_nnc_tensor_param_t []){
1893 params,
1894 }, 1, ccv_nnc_no_hint, &output_params, 1);
1895 const ccv_nnc_tensor_symbol_t softmax_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1896 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");
1897 outputs[0] = softmax_output;
1898}
1899
1900static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context);
1901
1902static const ccv_cnnp_model_vtab_t ccv_cnnp_softmax_isa = {
1903 .build = _ccv_cnnp_softmax_build,
1904 .copy = _ccv_cnnp_softmax_copy,
1905};
1906
1907ccv_cnnp_model_t* ccv_cnnp_softmax(const char* const name)
1908{
1909 ccv_cnnp_model_softmax_t* const model_softmax = (ccv_cnnp_model_softmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softmax_t));
1910 model_softmax->super.isa = &ccv_cnnp_softmax_isa;
1911 model_softmax->super.input_size = 1;
1912 model_softmax->super.outputs = &model_softmax->output;
1913 model_softmax->super.output_size = 1;
1914 ccv_cnnp_model_copy_name(&model_softmax->super, name);
1915 return (ccv_cnnp_model_t*)model_softmax;
1916}
1917
1918static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context)
1919{
1920 return ccv_cnnp_softmax(self->name);
1921}
1922
1923// MARK - Add Layer
1924
1925typedef struct {
1926 ccv_cnnp_model_t super;
1927 float p;
1928 float q;
1929 ccv_nnc_tensor_symbol_t output;
1930} ccv_cnnp_model_add_t;
1931
1932static 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)
1933{
1934 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);
1935 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
1936 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"
, 1936, __extension__ __PRETTY_FUNCTION__); }));
1937 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", 1937, __extension__ __PRETTY_FUNCTION__
); }));
1938 ccv_nnc_tensor_param_t input_params[2];
1939 int i;
1940 for (i = 0; i < 2; i++)
1941 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1942 ccv_nnc_tensor_param_t output_params;
1943 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);
1944 ccv_nnc_hint_tensor_auto(add, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1945 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1946 ccv_nnc_graph_exec_symbol_new(graph, add, inputs, input_size, outputs, output_size, "add");
1947}
1948
1949static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const self, void* const context);
1950
1951static const ccv_cnnp_model_vtab_t ccv_cnnp_add_isa = {
1952 .build = _ccv_cnnp_add_build,
1953 .copy = _ccv_cnnp_add_copy,
1954};
1955
1956ccv_cnnp_model_t* ccv_cnnp_add(const float p, const float q, const char* const name)
1957{
1958 ccv_cnnp_model_add_t* const model_add = (ccv_cnnp_model_add_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_add_t));
1959 model_add->super.isa = &ccv_cnnp_add_isa;
1960 model_add->super.input_size = 2;
1961 model_add->super.outputs = &model_add->output;
1962 model_add->super.output_size = 1;
1963 model_add->p = p;
1964 model_add->q = q;
1965 ccv_cnnp_model_copy_name(&model_add->super, name);
1966 return (ccv_cnnp_model_t*)model_add;
1967}
1968
1969static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const super, void* const context)
1970{
1971 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
1972 return ccv_cnnp_add(self->p, self->q, self->super.name);
1973}
1974
1975// MARK - Mul Layer
1976
1977typedef struct {
1978 ccv_cnnp_model_t super;
1979 ccv_nnc_tensor_symbol_t output;
1980 float p;
1981} ccv_cnnp_model_mul_t;
1982
1983static 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)
1984{
1985 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);
1986 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
1987 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"
, 1987, __extension__ __PRETTY_FUNCTION__); }));
1988 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", 1988, __extension__ __PRETTY_FUNCTION__
); }));
1989 ccv_nnc_tensor_param_t input_params[2];
1990 int i;
1991 for (i = 0; i < 2; i++)
1992 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1993 ccv_nnc_tensor_param_t output_params;
1994 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);
1995 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1996 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1997 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "mul");
1998}
1999
2000static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
2001
2002static const ccv_cnnp_model_vtab_t ccv_cnnp_mul_isa = {
2003 .build = _ccv_cnnp_mul_build,
2004 .copy = _ccv_cnnp_mul_copy,
2005};
2006
2007ccv_cnnp_model_t* ccv_cnnp_mul(const float p, const char* const name)
2008{
2009 ccv_cnnp_model_mul_t* const model_mul = (ccv_cnnp_model_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_mul_t));
2010 model_mul->super.isa = &ccv_cnnp_mul_isa;
2011 model_mul->super.input_size = 2;
2012 model_mul->super.outputs = &model_mul->output;
2013 model_mul->super.output_size = 1;
2014 model_mul->p = p;
2015 ccv_cnnp_model_copy_name(&model_mul->super, name);
2016 return (ccv_cnnp_model_t*)model_mul;
2017}
2018
2019static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2020{
2021 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2022 return ccv_cnnp_mul(self->p, self->super.name);
2023}
2024
2025// MARK - Scalar Mul Layer
2026
2027typedef struct {
2028 ccv_cnnp_model_t super;
2029 ccv_nnc_tensor_symbol_t output;
2030 float a;
2031} ccv_cnnp_model_scalar_mul_t;
2032
2033static 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)
2034{
2035 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);
2036 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"
, 2036, __extension__ __PRETTY_FUNCTION__); }));
2037 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", 2037, __extension__ __PRETTY_FUNCTION__
); }));
2038 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2039 ccv_nnc_tensor_param_t output_params;
2040 ccv_cnnp_model_scalar_mul_t* const self = (ccv_cnnp_model_scalar_mul_t*)super;
2041 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);
2042 ccv_nnc_hint_tensor_auto(scalar_mul, (ccv_nnc_tensor_param_t []){
2043 params,
2044 }, 1, ccv_nnc_no_hint, &output_params, 1);
2045 const ccv_nnc_tensor_symbol_t scalar_mul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2046 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");
2047 outputs[0] = scalar_mul_output;
2048}
2049
2050static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context);
2051
2052static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_mul_isa = {
2053 .build = _ccv_cnnp_scalar_mul_build,
2054 .copy = _ccv_cnnp_scalar_mul_copy,
2055};
2056
2057ccv_cnnp_model_t* ccv_cnnp_scalar_mul(const float a, const char* const name)
2058{
2059 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));
2060 model_scalar_mul->super.isa = &ccv_cnnp_scalar_mul_isa;
2061 model_scalar_mul->super.input_size = 1;
2062 model_scalar_mul->super.outputs = &model_scalar_mul->output;
2063 model_scalar_mul->super.output_size = 1;
2064 model_scalar_mul->a = a;
2065 ccv_cnnp_model_copy_name(&model_scalar_mul->super, name);
2066 return (ccv_cnnp_model_t*)model_scalar_mul;
2067}
2068
2069static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2070{
2071 const ccv_cnnp_model_scalar_mul_t* const self = (const ccv_cnnp_model_scalar_mul_t*)super;
2072 return ccv_cnnp_scalar_mul(self->a, self->super.name);
2073}
2074
2075// MARK - Div Layer
2076
2077typedef struct {
2078 ccv_cnnp_model_t super;
2079 ccv_nnc_tensor_symbol_t output;
2080 int reciprocal;
2081} ccv_cnnp_model_div_t;
2082
2083static 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)
2084{
2085 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2086 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);
2087 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", 2087, __extension__ __PRETTY_FUNCTION__
); }));
2088 ccv_nnc_tensor_param_t input_params[2];
2089 int i;
2090 ccv_nnc_tensor_param_t output_params;
2091 const ccv_nnc_cmd_t div = CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2092 if (self->reciprocal)
2093 {
2094 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"
, 2094, __extension__ __PRETTY_FUNCTION__); }));
2095 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2096 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2097 ccv_nnc_hint_tensor_auto(div, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2098 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2099 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");
2100 } else {
2101 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"
, 2101, __extension__ __PRETTY_FUNCTION__); }));
2102 for (i = 0; i < 2; i++)
2103 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2104 ccv_nnc_hint_tensor_auto(div, input_params, input_size, ccv_nnc_no_hint, &output_params, 1);
2105 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2106 ccv_nnc_graph_exec_symbol_new(graph, div, inputs, input_size, outputs, output_size, "div");
2107 }
2108}
2109
2110static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const self, void* const context);
2111
2112static const ccv_cnnp_model_vtab_t ccv_cnnp_div_isa = {
2113 .build = _ccv_cnnp_div_build,
2114 .copy = _ccv_cnnp_div_copy,
2115};
2116
2117ccv_cnnp_model_t* ccv_cnnp_div(const int reciprocal, const char* const name)
2118{
2119 ccv_cnnp_model_div_t* const model_div = (ccv_cnnp_model_div_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_div_t));
2120 model_div->super.isa = &ccv_cnnp_div_isa;
2121 model_div->super.input_size = reciprocal ? 1 : 2;
2122 model_div->super.outputs = &model_div->output;
2123 model_div->super.output_size = 1;
2124 model_div->reciprocal = reciprocal;
2125 ccv_cnnp_model_copy_name(&model_div->super, name);
2126 return (ccv_cnnp_model_t*)model_div;
2127}
2128
2129static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const super, void* const context)
2130{
2131 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2132 return ccv_cnnp_div(self->reciprocal, self->super.name);
2133}
2134
2135// MARK - Sqrt Layer
2136
2137typedef struct {
2138 ccv_cnnp_model_t super;
2139 ccv_nnc_tensor_symbol_t output;
2140} ccv_cnnp_model_sqrt_t;
2141
2142static 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)
2143{
2144 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);
2145 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", 2145, __extension__ __PRETTY_FUNCTION__
); }));
2146 ccv_nnc_tensor_param_t input_params[1];
2147 ccv_nnc_tensor_param_t output_params;
2148 const ccv_nnc_cmd_t sqrt = CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2149 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"
, 2149, __extension__ __PRETTY_FUNCTION__); }));
2150 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2151 ccv_nnc_hint_tensor_auto(sqrt, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2152 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2153 ccv_nnc_graph_exec_symbol_new(graph, sqrt, inputs, 1, outputs, output_size, "sqrt");
2154}
2155
2156static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const self, void* const context);
2157
2158static const ccv_cnnp_model_vtab_t ccv_cnnp_sqrt_isa = {
2159 .build = _ccv_cnnp_sqrt_build,
2160 .copy = _ccv_cnnp_sqrt_copy,
2161};
2162
2163ccv_cnnp_model_t* ccv_cnnp_sqrt(const char* const name)
2164{
2165 ccv_cnnp_model_sqrt_t* const model_sqrt = (ccv_cnnp_model_sqrt_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sqrt_t));
2166 model_sqrt->super.isa = &ccv_cnnp_sqrt_isa;
2167 model_sqrt->super.input_size = 1;
2168 model_sqrt->super.outputs = &model_sqrt->output;
2169 model_sqrt->super.output_size = 1;
2170 ccv_cnnp_model_copy_name(&model_sqrt->super, name);
2171 return (ccv_cnnp_model_t*)model_sqrt;
2172}
2173
2174static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const super, void* const context)
2175{
2176 const ccv_cnnp_model_sqrt_t* const self = (const ccv_cnnp_model_sqrt_t*)super;
2177 return ccv_cnnp_sqrt(self->super.name);
2178}
2179
2180// MARK - Cmul Layer
2181
2182typedef struct {
2183 ccv_cnnp_model_t super;
2184 ccv_nnc_tensor_symbol_t output;
2185} ccv_cnnp_model_cmul_t;
2186
2187static 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)
2188{
2189 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);
2190 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"
, 2190, __extension__ __PRETTY_FUNCTION__); }));
2191 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", 2191, __extension__ __PRETTY_FUNCTION__
); }));
2192 ccv_nnc_tensor_param_t input_params[2];
2193 int i;
2194 for (i = 0; i < 2; i++)
2195 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2196 ccv_nnc_tensor_param_t output_params;
2197 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);
2198 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2199 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2200 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "cmul");
2201}
2202
2203static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const self, void* const context);
2204
2205static const ccv_cnnp_model_vtab_t ccv_cnnp_cmul_isa = {
2206 .build = _ccv_cnnp_cmul_build,
2207 .copy = _ccv_cnnp_cmul_copy,
2208};
2209
2210ccv_cnnp_model_t* ccv_cnnp_cmul(const char* const name)
2211{
2212 ccv_cnnp_model_cmul_t* const model_cmul = (ccv_cnnp_model_cmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cmul_t));
2213 model_cmul->super.isa = &ccv_cnnp_cmul_isa;
2214 model_cmul->super.input_size = 2;
2215 model_cmul->super.outputs = &model_cmul->output;
2216 model_cmul->super.output_size = 1;
2217 ccv_cnnp_model_copy_name(&model_cmul->super, name);
2218 return (ccv_cnnp_model_t*)model_cmul;
2219}
2220
2221static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2222{
2223 return ccv_cnnp_cmul(super->name);
2224}
2225
2226// MARK - Transpose Layer
2227
2228typedef struct {
2229 ccv_cnnp_model_t super;
2230 ccv_nnc_tensor_symbol_t output;
2231 int transpose[2];
2232} ccv_cnnp_model_transpose_t;
2233
2234static 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)
2235{
2236 ccv_cnnp_model_transpose_t* const self = (ccv_cnnp_model_transpose_t*)super;
2237 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);
2238 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"
, 2238, __extension__ __PRETTY_FUNCTION__); }));
2239 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", 2239, __extension__ __PRETTY_FUNCTION__
); }));
2240 if (self->transpose[0] == self->transpose[1])
2241 {
2242 outputs[0] = inputs[0];
2243 return;
2244 }
2245 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2246 ccv_nnc_tensor_param_t output_params;
2247 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);
2248 ccv_nnc_hint_tensor_auto(transpose, (ccv_nnc_tensor_param_t []){
2249 params,
2250 }, 1, ccv_nnc_no_hint, &output_params, 1);
2251 const ccv_nnc_tensor_symbol_t transpose_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2252 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");
2253 outputs[0] = transpose_output;
2254}
2255
2256static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
2257
2258static const ccv_cnnp_model_vtab_t ccv_cnnp_transpose_isa = {
2259 .build = _ccv_cnnp_transpose_build,
2260 .copy = _ccv_cnnp_transpose_copy,
2261};
2262
2263ccv_cnnp_model_t* ccv_cnnp_transpose(const int axis_a, const int axis_b, const char* const name)
2264{
2265 ccv_cnnp_model_transpose_t* const model_transpose = (ccv_cnnp_model_transpose_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_transpose_t));
2266 model_transpose->super.isa = &ccv_cnnp_transpose_isa;
2267 model_transpose->super.input_size = 1;
2268 model_transpose->super.outputs = &model_transpose->output;
2269 model_transpose->super.output_size = 1;
2270 model_transpose->transpose[0] = axis_a;
2271 model_transpose->transpose[1] = axis_b;
2272 ccv_cnnp_model_copy_name(&model_transpose->super, name);
2273 return (ccv_cnnp_model_t*)model_transpose;
2274}
2275
2276static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
2277{
2278 const ccv_cnnp_model_transpose_t* const self = (const ccv_cnnp_model_transpose_t*)super;
2279 return ccv_cnnp_transpose(self->transpose[0], self->transpose[1], self->super.name);
2280}
2281
2282// MARK - Layer Norm Layer
2283
2284typedef struct {
2285 ccv_cnnp_model_t super;
2286 ccv_nnc_tensor_symbol_t output;
2287 ccv_nnc_tensor_symbol_t bias;
2288 ccv_nnc_tensor_symbol_t scale;
2289 ccv_nnc_cmd_param_t params;
2290} ccv_cnnp_model_layer_norm_t;
2291
2292static 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)
2293{
2294 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);
2295 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"
, 2295, __extension__ __PRETTY_FUNCTION__); }));
2296 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", 2296, __extension__ __PRETTY_FUNCTION__
); }));
2297 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2298 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2299 ccv_nnc_tensor_param_t bias_params = params;
2300 const int nd = ccv_nnc_tensor_nd(params.dim);
2301 int i;
2302 for (i = 0; i < nd; i++)
2303 bias_params.dim[i] = 1;
2304 for (i = 0; i < self->params.lnorm.count; i++)
2305 bias_params.dim[self->params.lnorm.axis[i]] = params.dim[self->params.lnorm.axis[i]];
2306 if (self->params.lnorm.elementwise_affine)
2307 {
2308 // Both scale and bias are shared between if this model is reused.
2309 if (!self->scale.graph)
2310 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2311 if (!self->bias.graph)
2312 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2313 }
2314 const ccv_nnc_cmd_t layer_norm = ccv_nnc_cmd(CCV_NNC_LAYER_NORM_FORWARD, 0, self->params, 0);
2315 ccv_nnc_tensor_param_t output_params[3];
2316 if (self->params.lnorm.elementwise_affine)
2317 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2318 params,
2319 bias_params,
2320 bias_params,
2321 }, 3, ccv_nnc_no_hint, output_params, 3);
2322 else
2323 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2324 params,
2325 }, 1, ccv_nnc_no_hint, output_params, 3);
2326 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2327 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
2328 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
2329 if (self->params.lnorm.elementwise_affine)
2330 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");
2331 else
2332 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");
2333 outputs[0] = output;
2334}
2335
2336static 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)
2337{
2338 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2339 if (self->scale.graph)
2340 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);
2341 if (self->bias.graph)
2342 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);
2343}
2344
2345static 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)
2346{
2347 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2348 if (self->scale.graph)
2349 add_to_array(parameters, self->scale, is_trainable);
2350 if (self->bias.graph)
2351 add_to_array(parameters, self->bias, is_trainable);
2352}
2353
2354static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
2355
2356static const ccv_cnnp_model_vtab_t ccv_cnnp_layer_norm_isa = {
2357 .build = _ccv_cnnp_layer_norm_build,
2358 .init_states = _ccv_cnnp_layer_norm_init_states,
2359 .add_to_parameter = _ccv_cnnp_layer_norm_add_to_parameter,
2360 .copy = _ccv_cnnp_layer_norm_copy,
2361};
2362
2363ccv_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)
2364{
2365 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));
2366 model_layer_norm->super.isa = &ccv_cnnp_layer_norm_isa;
2367 model_layer_norm->super.input_size = 1;
2368 model_layer_norm->super.outputs = &model_layer_norm->output;
2369 model_layer_norm->super.output_size = 1;
2370 model_layer_norm->super.is_trainable = is_trainable;
2371 ccv_cnnp_model_copy_name(&model_layer_norm->super, name);
2372 model_layer_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2373 model_layer_norm->scale.graph = 0;
2374 model_layer_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
2375 model_layer_norm->bias.graph = 0;
2376 model_layer_norm->params.lnorm.epsilon = epsilon;
2377 model_layer_norm->params.lnorm.count = axis_count;
2378 model_layer_norm->params.lnorm.elementwise_affine = elementwise_affine;
2379 memcpy(model_layer_norm->params.lnorm.axis, axis, sizeof(int) * axis_count);
2380 return (ccv_cnnp_model_t*)model_layer_norm;
2381}
2382
2383static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
2384{
2385 const ccv_cnnp_model_layer_norm_t* const self = (const ccv_cnnp_model_layer_norm_t*)super;
2386 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);
2387}
2388
2389// MARK - Group Norm Layer
2390
2391typedef struct {
2392 ccv_cnnp_model_t super;
2393 ccv_nnc_tensor_symbol_t output;
2394 ccv_nnc_tensor_symbol_t bias;
2395 ccv_nnc_tensor_symbol_t scale;
2396 ccv_nnc_cmd_param_t params;
2397} ccv_cnnp_model_group_norm_t;
2398
2399static 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)
2400{
2401 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);
2402 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"
, 2402, __extension__ __PRETTY_FUNCTION__); }));
2403 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", 2403, __extension__ __PRETTY_FUNCTION__
); }));
2404 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2405 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2406 ccv_nnc_tensor_param_t bias_params = params;
2407 const int nd = ccv_nnc_tensor_nd(params.dim);
2408 int i;
2409 for (i = 0; i < nd; i++)
2410 bias_params.dim[i] = 1;
2411 bias_params.dim[self->params.gnorm.group_axis] = params.dim[self->params.gnorm.group_axis];
2412 if (self->params.gnorm.elementwise_affine)
2413 {
2414 // Both scale and bias are shared between if this model is reused.
2415 if (!self->scale.graph)
2416 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2417 if (!self->bias.graph)
2418 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2419 }
2420 const ccv_nnc_cmd_t group_norm = ccv_nnc_cmd(CCV_NNC_GROUP_NORM_FORWARD, 0, self->params, 0);
2421 ccv_nnc_tensor_param_t output_params[3];
2422 if (self->params.gnorm.elementwise_affine)
2423 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
2424 params,
2425 bias_params,
2426 bias_params,
2427 }, 3, ccv_nnc_no_hint, output_params, 3);
2428 else
2429 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
2430 params,
2431 }, 1, ccv_nnc_no_hint, output_params, 3);
2432 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2433 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
2434 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
2435 if (self->params.gnorm.elementwise_affine)
2436 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");
2437 else
2438 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");
2439 outputs[0] = output;
2440}
2441
2442static 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)
2443{
2444 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2445 if (self->scale.graph)
2446 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);
2447 if (self->bias.graph)
2448 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);
2449}
2450
2451static 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)
2452{
2453 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2454 if (self->scale.graph)
2455 add_to_array(parameters, self->scale, is_trainable);
2456 if (self->bias.graph)
2457 add_to_array(parameters, self->bias, is_trainable);
2458}
2459
2460static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
2461
2462static const ccv_cnnp_model_vtab_t ccv_cnnp_group_norm_isa = {
2463 .build = _ccv_cnnp_group_norm_build,
2464 .init_states = _ccv_cnnp_group_norm_init_states,
2465 .add_to_parameter = _ccv_cnnp_group_norm_add_to_parameter,
2466 .copy = _ccv_cnnp_group_norm_copy,
2467};
2468
2469ccv_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)
2470{
2471 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));
2472 model_group_norm->super.isa = &ccv_cnnp_group_norm_isa;
2473 model_group_norm->super.input_size = 1;
2474 model_group_norm->super.outputs = &model_group_norm->output;
2475 model_group_norm->super.output_size = 1;
2476 model_group_norm->super.is_trainable = is_trainable;
2477 ccv_cnnp_model_copy_name(&model_group_norm->super, name);
2478 model_group_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2479 model_group_norm->scale.graph = 0;
2480 model_group_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
2481 model_group_norm->bias.graph = 0;
2482 model_group_norm->params.gnorm.group_axis = group_axis;
2483 model_group_norm->params.gnorm.groups = groups;
2484 model_group_norm->params.gnorm.epsilon = epsilon;
2485 model_group_norm->params.gnorm.reduce_count = axis_count;
2486 model_group_norm->params.gnorm.elementwise_affine = elementwise_affine;
2487 memcpy(model_group_norm->params.gnorm.reduce_axis, reduce_axis, sizeof(int) * axis_count);
2488 return (ccv_cnnp_model_t*)model_group_norm;
2489}
2490
2491static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
2492{
2493 const ccv_cnnp_model_group_norm_t* const self = (const ccv_cnnp_model_group_norm_t*)super;
2494 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);
2495}
2496
2497// MARK - RMSNorm Layer
2498
2499typedef struct {
2500 ccv_cnnp_model_t super;
2501 ccv_nnc_tensor_symbol_t output;
2502 ccv_nnc_tensor_symbol_t scale;
2503 ccv_nnc_cmd_param_t params;
2504} ccv_cnnp_model_rmsnorm_t;
2505
2506static 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)
2507{
2508 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);
2509 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"
, 2509, __extension__ __PRETTY_FUNCTION__); }));
2510 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", 2510, __extension__ __PRETTY_FUNCTION__
); }));
2511 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2512 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2513 ccv_nnc_tensor_param_t scale_params = params;
2514 const int nd = ccv_nnc_tensor_nd(params.dim);
2515 int i;
2516 for (i = 0; i < nd; i++)
2517 scale_params.dim[i] = 1;
2518 for (i = 0; i < self->params.rmsnorm.count; i++)
2519 scale_params.dim[self->params.rmsnorm.axis[i]] = params.dim[self->params.rmsnorm.axis[i]];
2520 // Both scale and bias are shared between if this model is reused.
2521 if (!self->scale.graph)
2522 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
2523 const ccv_nnc_cmd_t rmsnorm = ccv_nnc_cmd(CCV_NNC_RMSNORM_FORWARD, 0, self->params, 0);
2524 ccv_nnc_tensor_param_t output_params[2];
2525 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
2526 params,
2527 scale_params,
2528 }, 2, ccv_nnc_no_hint, output_params, 2);
2529 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2530 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_inv_std");
2531 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");
2532 outputs[0] = output;
2533}
2534
2535static 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)
2536{
2537 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2538 if (self->scale.graph)
2539 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);
2540}
2541
2542static 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)
2543{
2544 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
2545 if (self->scale.graph)
2546 add_to_array(parameters, self->scale, is_trainable);
2547}
2548
2549static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context);
2550
2551static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_isa = {
2552 .build = _ccv_cnnp_rmsnorm_build,
2553 .init_states = _ccv_cnnp_rmsnorm_init_states,
2554 .add_to_parameter = _ccv_cnnp_rmsnorm_add_to_parameter,
2555 .copy = _ccv_cnnp_rmsnorm_copy,
2556};
2557
2558ccv_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)
2559{
2560 ccv_cnnp_model_rmsnorm_t* const model_rmsnorm = (ccv_cnnp_model_rmsnorm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_t));
2561 model_rmsnorm->super.isa = &ccv_cnnp_rmsnorm_isa;
2562 model_rmsnorm->super.input_size = 1;
2563 model_rmsnorm->super.outputs = &model_rmsnorm->output;
2564 model_rmsnorm->super.output_size = 1;
2565 model_rmsnorm->super.is_trainable = is_trainable;
2566 ccv_cnnp_model_copy_name(&model_rmsnorm->super, name);
2567 model_rmsnorm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2568 model_rmsnorm->scale.graph = 0;
2569 model_rmsnorm->params.rmsnorm.epsilon = epsilon;
2570 model_rmsnorm->params.rmsnorm.count = axis_count;
2571 memcpy(model_rmsnorm->params.lnorm.axis, axis, sizeof(int) * axis_count);
2572 return (ccv_cnnp_model_t*)model_rmsnorm;
2573}
2574
2575static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context)
2576{
2577 const ccv_cnnp_model_rmsnorm_t* const self = (const ccv_cnnp_model_rmsnorm_t*)super;
2578 return ccv_cnnp_rmsnorm(self->params.rmsnorm.epsilon, self->params.rmsnorm.axis, self->params.rmsnorm.count, self->super.is_trainable, self->super.name);
2579}
2580
2581// MARK - Batched Matrix Mul Layer
2582
2583typedef struct {
2584 ccv_cnnp_model_t super;
2585 ccv_nnc_tensor_symbol_t output;
2586 int transpose_a[2];
2587 int transpose_b[2];
2588 int flags;
2589} ccv_cnnp_model_matmul_t;
2590
2591static 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)
2592{
2593 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);
2594 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"
, 2594, __extension__ __PRETTY_FUNCTION__); }));
2595 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", 2595, __extension__ __PRETTY_FUNCTION__
); }));
2596 ccv_cnnp_model_matmul_t* const self = (ccv_cnnp_model_matmul_t*)super;
2597 ccv_nnc_tensor_param_t a_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2598 ccv_nnc_tensor_param_t b_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
2599 ccv_nnc_tensor_param_t output_params;
2600 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);
2601 matmul.info.blas.flags = self->flags;
2602 ccv_nnc_hint_tensor_auto(matmul, (ccv_nnc_tensor_param_t []){
2603 a_params,
2604 b_params,
2605 }, 2, ccv_nnc_no_hint, &output_params, 1);
2606 const ccv_nnc_tensor_symbol_t matmul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2607 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");
2608 outputs[0] = matmul_output;
2609}
2610
2611static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context);
2612
2613static const ccv_cnnp_model_vtab_t ccv_cnnp_matmul_isa = {
2614 .build = _ccv_cnnp_matmul_build,
2615 .copy = _ccv_cnnp_matmul_copy,
2616};
2617
2618ccv_cnnp_model_t* ccv_cnnp_matmul(const int transpose_a[2], const int transpose_b[2], const int flags, const char* const name)
2619{
2620 ccv_cnnp_model_matmul_t* const model_matmul = (ccv_cnnp_model_matmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_matmul_t));
2621 model_matmul->super.isa = &ccv_cnnp_matmul_isa;
2622 model_matmul->super.input_size = 2;
2623 model_matmul->super.outputs = &model_matmul->output;
2624 model_matmul->super.output_size = 1;
2625 model_matmul->transpose_a[0] = transpose_a[0];
2626 model_matmul->transpose_a[1] = transpose_a[1];
2627 model_matmul->transpose_b[0] = transpose_b[0];
2628 model_matmul->transpose_b[1] = transpose_b[1];
2629 model_matmul->flags = flags;
2630 ccv_cnnp_model_copy_name(&model_matmul->super, name);
2631 return (ccv_cnnp_model_t*)model_matmul;
2632}
2633
2634static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2635{
2636 const ccv_cnnp_model_matmul_t* const self = (const ccv_cnnp_model_matmul_t*)super;
2637 return ccv_cnnp_matmul(self->transpose_a, self->transpose_b, self->flags, self->super.name);
2638}
2639
2640// MARK - Dropout Layer
2641
2642typedef struct {
2643 ccv_cnnp_model_t super;
2644 ccv_nnc_tensor_symbol_t output;
2645 ccv_nnc_graph_exec_symbol_t dropout;
2646 float p;
2647 int entirety;
2648} ccv_cnnp_model_dropout_t;
2649
2650static 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)
2651{
2652 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);
2653 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"
, 2653, __extension__ __PRETTY_FUNCTION__); }));
2654 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", 2654, __extension__ __PRETTY_FUNCTION__
); }));
2655 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2656 ccv_nnc_tensor_param_t output_params[2];
2657 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
2658 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);
2659 ccv_nnc_hint_tensor_auto(dropout, (ccv_nnc_tensor_param_t []){
2660 params,
2661 }, 1, ccv_nnc_no_hint, output_params, 2);
2662 const ccv_nnc_tensor_symbol_t dropout_output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2663 const ccv_nnc_tensor_symbol_t mask = ccv_nnc_tensor_symbol_new(graph, output_params[1], "mask");
2664 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");
2665 outputs[0] = dropout_output;
2666}
2667
2668static 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)
2669{
2670 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
2671 if (self->dropout.graph)
2672 {
2673 if (is_test)
2674 // During test, the dropout is not applied. Data transfer is perfect because if these are the same tensor, it will skip.
2675 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);
2676 else
2677 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);
2678 }
2679}
2680
2681static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context);
2682
2683static const ccv_cnnp_model_vtab_t ccv_cnnp_dropout_isa = {
2684 .build = _ccv_cnnp_dropout_build,
2685 .set_is_test = _ccv_cnnp_dropout_set_is_test,
2686 .copy = _ccv_cnnp_dropout_copy,
2687};
2688
2689ccv_cnnp_model_t* ccv_cnnp_dropout(const float p, const int entirety, const char* const name)
2690{
2691 ccv_cnnp_model_dropout_t* const model_dropout = (ccv_cnnp_model_dropout_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dropout_t));
2692 model_dropout->super.isa = &ccv_cnnp_dropout_isa;
2693 model_dropout->super.input_size = 1;
2694 model_dropout->super.outputs = &model_dropout->output;
2695 model_dropout->super.output_size = 1;
2696 model_dropout->p = p;
2697 model_dropout->entirety = entirety;
2698 ccv_cnnp_model_copy_name(&model_dropout->super, name);
2699 return (ccv_cnnp_model_t*)model_dropout;
2700}
2701
2702static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context)
2703{
2704 const ccv_cnnp_model_dropout_t* const self = (const ccv_cnnp_model_dropout_t*)super;
2705 return ccv_cnnp_dropout(self->p, self->entirety, self->super.name);
2706}
2707
2708// MARK - Masked Fill Layer
2709
2710typedef struct {
2711 ccv_cnnp_model_t super;
2712 ccv_nnc_tensor_symbol_t output;
2713 float eq;
2714 float fill;
2715} ccv_cnnp_model_masked_fill_t;
2716
2717static 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)
2718{
2719 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);
2720 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"
, 2720, __extension__ __PRETTY_FUNCTION__); }));
2721 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", 2721, __extension__ __PRETTY_FUNCTION__
); }));
2722 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2723 ccv_cnnp_model_masked_fill_t* const self = (ccv_cnnp_model_masked_fill_t*)super;
2724 const ccv_nnc_tensor_symbol_t masked_fill_output = ccv_nnc_tensor_symbol_new(graph, params, 0);
2725 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");
2726 outputs[0] = masked_fill_output;
2727}
2728
2729static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context);
2730
2731static const ccv_cnnp_model_vtab_t ccv_cnnp_masked_fill_isa = {
2732 .build = _ccv_cnnp_masked_fill_build,
2733 .copy = _ccv_cnnp_masked_fill_copy,
2734};
2735
2736ccv_cnnp_model_t* ccv_cnnp_masked_fill(const float eq, const float fill, const char* const name)
2737{
2738 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));
2739 model_masked_fill->super.isa = &ccv_cnnp_masked_fill_isa;
2740 model_masked_fill->super.input_size = 2;
2741 model_masked_fill->super.outputs = &model_masked_fill->output;
2742 model_masked_fill->super.output_size = 1;
2743 model_masked_fill->eq = eq;
2744 model_masked_fill->fill = fill;
2745 ccv_cnnp_model_copy_name(&model_masked_fill->super, name);
2746 return (ccv_cnnp_model_t*)model_masked_fill;
2747}
2748
2749static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context)
2750{
2751 const ccv_cnnp_model_masked_fill_t* const self = (const ccv_cnnp_model_masked_fill_t*)super;
2752 return ccv_cnnp_masked_fill(self->eq, self->fill, self->super.name);
2753}
2754
2755// MARK - Index Select Layer
2756
2757typedef struct {
2758 ccv_cnnp_model_t super;
2759 ccv_nnc_tensor_symbol_t output;
2760} ccv_cnnp_model_index_select_t;
2761
2762static 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)
2763{
2764 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);
2765 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"
, 2765, __extension__ __PRETTY_FUNCTION__); }));
2766 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", 2766, __extension__ __PRETTY_FUNCTION__
); }));
2767 const ccv_nnc_tensor_param_t vocab_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2768 const ccv_nnc_tensor_param_t index_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
2769 ccv_nnc_tensor_param_t output_params;
2770 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);
2771 ccv_nnc_hint_tensor_auto(index_select, (ccv_nnc_tensor_param_t []){
2772 vocab_params,
2773 index_params,
2774 }, 2, ccv_nnc_no_hint, &output_params, 1);
2775 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2776 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");
2777 outputs[0] = output;
2778}
2779
2780static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context);
2781
2782static const ccv_cnnp_model_vtab_t ccv_cnnp_index_select_isa = {
2783 .build = _ccv_cnnp_index_select_build,
2784 .copy = _ccv_cnnp_index_select_copy,
2785};
2786
2787ccv_cnnp_model_t* ccv_cnnp_index_select(const char* const name)
2788{
2789 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));
2790 model_index_select->super.isa = &ccv_cnnp_index_select_isa;
2791 model_index_select->super.input_size = 2;
2792 model_index_select->super.outputs = &model_index_select->output;
2793 model_index_select->super.output_size = 1;
2794 ccv_cnnp_model_copy_name(&model_index_select->super, name);
2795 return (ccv_cnnp_model_t*)model_index_select;
2796}
2797
2798static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context)
2799{
2800 ccv_cnnp_model_index_select_t* const self = (ccv_cnnp_model_index_select_t*)super;
2801 return ccv_cnnp_index_select(self->super.name);
2802}
2803
2804// MARK - Embedding Layer
2805
2806typedef struct {
2807 ccv_cnnp_model_t super;
2808 ccv_nnc_tensor_symbol_t output;
2809 ccv_nnc_tensor_symbol_t vocab;
2810 int datatype;
2811 int vocab_size;
2812 int embed_size;
2813} ccv_cnnp_model_embedding_t;
2814
2815static 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)
2816{
2817 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2818 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);
2819 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"
, 2819, __extension__ __PRETTY_FUNCTION__); }));
2820 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", 2820, __extension__ __PRETTY_FUNCTION__
); }));
2821 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2822 ccv_nnc_tensor_param_t vocab_params = params;
2823 memset(vocab_params.dim, 0, sizeof(vocab_params.dim));
2824 vocab_params.datatype = self->datatype;
2825 vocab_params.dim[0] = self->vocab_size;
2826 vocab_params.dim[1] = self->embed_size;
2827 if (!self->vocab.graph)
2828 self->vocab = ccv_nnc_tensor_symbol_new(graph, vocab_params, "vocab");
2829 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", 2829
, __extension__ __PRETTY_FUNCTION__); }));
2830 ccv_nnc_tensor_param_t output_params;
2831 const ccv_nnc_cmd_t embedding = CMD_INDEX_SELECT_FORWARD()ccv_nnc_cmd(CCV_NNC_INDEX_SELECT_FORWARD, 0, ccv_nnc_cmd_auto
, 0);
2832 ccv_nnc_hint_tensor_auto(embedding, (ccv_nnc_tensor_param_t []){
2833 vocab_params,
2834 params,
2835 }, 2, ccv_nnc_no_hint, &output_params, 1);
2836 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2837 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");
2838 outputs[0] = output;
2839}
2840
2841static 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)
2842{
2843 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2844 const float std = sqrtf(2) / sqrtf(self->vocab_size + self->embed_size);
2845 const float bound = sqrtf(3) * std;
2846 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);
2847}
2848
2849static 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)
2850{
2851 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2852 add_to_array(parameters, self->vocab, is_trainable);
2853}
2854
2855static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context);
2856
2857static const ccv_cnnp_model_vtab_t ccv_cnnp_embedding_isa = {
2858 .build = _ccv_cnnp_embedding_build,
2859 .init_states = _ccv_cnnp_embedding_init_states,
2860 .add_to_parameter = _ccv_cnnp_embedding_add_to_parameter,
2861 .copy = _ccv_cnnp_embedding_copy,
2862};
2863
2864ccv_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)
2865{
2866 ccv_cnnp_model_embedding_t* const model_embedding = (ccv_cnnp_model_embedding_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_embedding_t));
2867 model_embedding->super.isa = &ccv_cnnp_embedding_isa;
2868 model_embedding->super.input_size = 1;
2869 model_embedding->super.outputs = &model_embedding->output;
2870 model_embedding->super.output_size = 1;
2871 model_embedding->super.is_trainable = is_trainable;
2872 ccv_cnnp_model_copy_name(&model_embedding->super, name);
2873 model_embedding->vocab.d = CCV_NNC_NO_TENSOR_SYMBOL;
2874 model_embedding->vocab.graph = 0;
2875 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", 2875, __extension__ __PRETTY_FUNCTION__
); }));
2876 model_embedding->datatype = datatype;
2877 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", 2877, __extension__ __PRETTY_FUNCTION__
); }));
2878 model_embedding->vocab_size = vocab_size;
2879 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", 2879, __extension__ __PRETTY_FUNCTION__
); }));
2880 model_embedding->embed_size = embed_size;
2881 return (ccv_cnnp_model_t*)model_embedding;
2882}
2883
2884static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context)
2885{
2886 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
2887 return ccv_cnnp_embedding(self->datatype, self->vocab_size, self->embed_size, self->super.is_trainable, self->super.name);
2888}
2889
2890// MARK - Pool Layers
2891
2892typedef struct {
2893 ccv_cnnp_model_t super;
2894 ccv_nnc_tensor_symbol_t output;
2895 int type;
2896 float width_scale;
2897 float height_scale;
2898 int align_corners;
2899} ccv_cnnp_model_upsample_t;
2900
2901static 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)
2902{
2903 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);
2904 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"
, 2904, __extension__ __PRETTY_FUNCTION__); }));
2905 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", 2905, __extension__ __PRETTY_FUNCTION__
); }));
2906 ccv_cnnp_model_upsample_t* const self = (ccv_cnnp_model_upsample_t*)super;
2907 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2908 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);
2909 ccv_nnc_tensor_param_t output_params;
2910 ccv_nnc_hint_tensor_auto(cmd, &params, 1, ccv_nnc_no_hint, &output_params, 1);
2911 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2912 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");
2913 outputs[0] = output;
2914}
2915
2916static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context);
2917
2918static const ccv_cnnp_model_vtab_t ccv_cnnp_upsample_isa = {
2919 .build = _ccv_cnnp_upsample_build,
2920 .copy = _ccv_cnnp_upsample_copy,
2921};
2922
2923ccv_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)
2924{
2925 ccv_cnnp_model_upsample_t* const model_upsample = (ccv_cnnp_model_upsample_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_upsample_t));
2926 model_upsample->super.isa = &ccv_cnnp_upsample_isa;
2927 model_upsample->super.input_size = 1;
2928 model_upsample->super.outputs = &model_upsample->output;
2929 model_upsample->super.output_size = 1;
2930 ccv_cnnp_model_copy_name(&model_upsample->super, name);
2931 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", 2931, __extension__ __PRETTY_FUNCTION__
); }));
2932 model_upsample->type = type;
2933 model_upsample->width_scale = width_scale;
2934 model_upsample->height_scale = height_scale;
2935 model_upsample->align_corners = align_corners;
2936 return (ccv_cnnp_model_t*)model_upsample;
2937}
2938
2939static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context)
2940{
2941 const ccv_cnnp_model_upsample_t* const self = (const ccv_cnnp_model_upsample_t*)super;
2942 return ccv_cnnp_upsample(self->type, self->width_scale, self->height_scale, self->align_corners, self->super.name);
2943}
2944
2945// MARK - Reduce Sum Layer
2946
2947typedef struct {
2948 ccv_cnnp_model_t super;
2949 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
2950 int count;
2951 ccv_nnc_tensor_symbol_t output;
2952} ccv_cnnp_model_reduce_sum_t;
2953
2954static 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)
2955{
2956 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);
2957 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
2958 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"
, 2958, __extension__ __PRETTY_FUNCTION__); }));
2959 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", 2959, __extension__ __PRETTY_FUNCTION__
); }));
2960 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2961 ccv_nnc_tensor_param_t output_params;
2962 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);
2963 int i;
2964 for (i = 0; i < self->count; i++)
2965 reduce_sum.info.reduce.axis[i] = self->axis[i];
2966 reduce_sum.info.reduce.count = self->count;
2967 ccv_nnc_hint_tensor_auto(reduce_sum, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2968 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2969 ccv_nnc_graph_exec_symbol_new(graph, reduce_sum, inputs, input_size, outputs, output_size, "reduce_sum");
2970}
2971
2972static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
2973
2974static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_sum_isa = {
2975 .build = _ccv_cnnp_reduce_sum_build,
2976 .copy = _ccv_cnnp_reduce_sum_copy,
2977};
2978
2979ccv_cnnp_model_t* ccv_cnnp_reduce_sum(const int* const axis, const int axis_count, const char* const name)
2980{
2981 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));
2982 model_reduce_sum->super.isa = &ccv_cnnp_reduce_sum_isa;
2983 model_reduce_sum->super.input_size = 1;
2984 model_reduce_sum->super.outputs = &model_reduce_sum->output;
2985 model_reduce_sum->super.output_size = 1;
2986 ccv_cnnp_model_copy_name(&model_reduce_sum->super, name);
2987 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", 2987, __extension__ __PRETTY_FUNCTION__
); }));
2988 int i;
2989 for (i = 0; i < axis_count; i++)
2990 model_reduce_sum->axis[i] = axis[i];
2991 model_reduce_sum->count = axis_count;
2992 return (ccv_cnnp_model_t*)model_reduce_sum;
2993}
2994
2995static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const super, void* const context)
2996{
2997 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
2998 return ccv_cnnp_reduce_sum(self->axis, self->count, self->super.name);
2999}
3000
3001// MARK - Reduce Mean Layer
3002
3003typedef struct {
3004 ccv_cnnp_model_t super;
3005 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3006 int count;
3007 ccv_nnc_tensor_symbol_t output;
3008} ccv_cnnp_model_reduce_mean_t;
3009
3010static 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)
3011{
3012 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);
3013 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3014 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"
, 3014, __extension__ __PRETTY_FUNCTION__); }));
3015 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", 3015, __extension__ __PRETTY_FUNCTION__
); }));
3016 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3017 ccv_nnc_tensor_param_t output_params;
3018 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);
3019 int i;
3020 for (i = 0; i < self->count; i++)
3021 reduce_mean.info.reduce.axis[i] = self->axis[i];
3022 reduce_mean.info.reduce.count = self->count;
3023 ccv_nnc_hint_tensor_auto(reduce_mean, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3024 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3025 ccv_nnc_graph_exec_symbol_new(graph, reduce_mean, inputs, input_size, outputs, output_size, "reduce_mean");
3026}
3027
3028static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const self, void* const context);
3029
3030static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_mean_isa = {
3031 .build = _ccv_cnnp_reduce_mean_build,
3032 .copy = _ccv_cnnp_reduce_mean_copy,
3033};
3034
3035ccv_cnnp_model_t* ccv_cnnp_reduce_mean(const int* const axis, const int axis_count, const char* const name)
3036{
3037 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));
3038 model_reduce_mean->super.isa = &ccv_cnnp_reduce_mean_isa;
3039 model_reduce_mean->super.input_size = 1;
3040 model_reduce_mean->super.outputs = &model_reduce_mean->output;
3041 model_reduce_mean->super.output_size = 1;
3042 ccv_cnnp_model_copy_name(&model_reduce_mean->super, name);
3043 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", 3043, __extension__ __PRETTY_FUNCTION__
); }));
3044 int i;
3045 for (i = 0; i < axis_count; i++)
3046 model_reduce_mean->axis[i] = axis[i];
3047 model_reduce_mean->count = axis_count;
3048 return (ccv_cnnp_model_t*)model_reduce_mean;
3049}
3050
3051static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const super, void* const context)
3052{
3053 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3054 return ccv_cnnp_reduce_mean(self->axis, self->count, self->super.name);
3055}
3056
3057// MARK - Reduce Max Layer
3058
3059typedef struct {
3060 ccv_cnnp_model_t super;
3061 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3062 int count;
3063 ccv_nnc_tensor_symbol_t output;
3064} ccv_cnnp_model_reduce_max_t;
3065
3066static 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)
3067{
3068 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);
3069 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3070 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"
, 3070, __extension__ __PRETTY_FUNCTION__); }));
3071 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", 3071, __extension__ __PRETTY_FUNCTION__
); }));
3072 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3073 ccv_nnc_tensor_param_t output_params;
3074 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);
3075 int i;
3076 for (i = 0; i < self->count; i++)
3077 reduce_max.info.reduce.axis[i] = self->axis[i];
3078 reduce_max.info.reduce.count = self->count;
3079 ccv_nnc_hint_tensor_auto(reduce_max, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3080 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3081 ccv_nnc_graph_exec_symbol_new(graph, reduce_max, inputs, input_size, outputs, output_size, "reduce_max");
3082}
3083
3084static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const self, void* const context);
3085
3086static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_max_isa = {
3087 .build = _ccv_cnnp_reduce_max_build,
3088 .copy = _ccv_cnnp_reduce_max_copy,
3089};
3090
3091ccv_cnnp_model_t* ccv_cnnp_reduce_max(const int* const axis, const int axis_count, const char* const name)
3092{
3093 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));
3094 model_reduce_max->super.isa = &ccv_cnnp_reduce_max_isa;
3095 model_reduce_max->super.input_size = 1;
3096 model_reduce_max->super.outputs = &model_reduce_max->output;
3097 model_reduce_max->super.output_size = 1;
3098 ccv_cnnp_model_copy_name(&model_reduce_max->super, name);
3099 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", 3099, __extension__ __PRETTY_FUNCTION__
); }));
3100 int i;
3101 for (i = 0; i < axis_count; i++)
3102 model_reduce_max->axis[i] = axis[i];
3103 model_reduce_max->count = axis_count;
3104 return (ccv_cnnp_model_t*)model_reduce_max;
3105}
3106
3107static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const super, void* const context)
3108{
3109 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3110 return ccv_cnnp_reduce_max(self->axis, self->count, self->super.name);
3111}
3112
3113// MARK - Reduce Min Layer
3114
3115typedef struct {
3116 ccv_cnnp_model_t super;
3117 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3118 int count;
3119 ccv_nnc_tensor_symbol_t output;
3120} ccv_cnnp_model_reduce_min_t;
3121
3122static 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)
3123{
3124 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);
3125 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3126 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"
, 3126, __extension__ __PRETTY_FUNCTION__); }));
3127 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", 3127, __extension__ __PRETTY_FUNCTION__
); }));
3128 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3129 ccv_nnc_tensor_param_t output_params;
3130 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);
3131 int i;
3132 for (i = 0; i < self->count; i++)
3133 reduce_min.info.reduce.axis[i] = self->axis[i];
3134 reduce_min.info.reduce.count = self->count;
3135 ccv_nnc_hint_tensor_auto(reduce_min, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3136 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3137 ccv_nnc_graph_exec_symbol_new(graph, reduce_min, inputs, input_size, outputs, output_size, "reduce_min");
3138}
3139
3140static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const self, void* const context);
3141
3142static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_min_isa = {
3143 .build = _ccv_cnnp_reduce_min_build,
3144 .copy = _ccv_cnnp_reduce_min_copy,
3145};
3146
3147ccv_cnnp_model_t* ccv_cnnp_reduce_min(const int* const axis, const int axis_count, const char* const name)
3148{
3149 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));
3150 model_reduce_min->super.isa = &ccv_cnnp_reduce_min_isa;
3151 model_reduce_min->super.input_size = 1;
3152 model_reduce_min->super.outputs = &model_reduce_min->output;
3153 model_reduce_min->super.output_size = 1;
3154 ccv_cnnp_model_copy_name(&model_reduce_min->super, name);
3155 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", 3155, __extension__ __PRETTY_FUNCTION__
); }));
3156 int i;
3157 for (i = 0; i < axis_count; i++)
3158 model_reduce_min->axis[i] = axis[i];
3159 model_reduce_min->count = axis_count;
3160 return (ccv_cnnp_model_t*)model_reduce_min;
3161}
3162
3163static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const super, void* const context)
3164{
3165 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3166 return ccv_cnnp_reduce_min(self->axis, self->count, self->super.name);
3167}
3168
3169// MARK - Reduce Norm2 Layer
3170
3171typedef struct {
3172 ccv_cnnp_model_t super;
3173 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3174 int count;
3175 ccv_nnc_tensor_symbol_t output;
3176} ccv_cnnp_model_reduce_norm2_t;
3177
3178static 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)
3179{
3180 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
3181 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);
3182 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"
, 3182, __extension__ __PRETTY_FUNCTION__); }));
3183 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", 3183, __extension__ __PRETTY_FUNCTION__
); }));
3184 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3185 ccv_nnc_tensor_param_t output_params;
3186 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);
3187 int i;
3188 for (i = 0; i < self->count; i++)
3189 reduce_norm2.info.reduce.axis[i] = self->axis[i];
3190 reduce_norm2.info.reduce.count = self->count;
3191 ccv_nnc_hint_tensor_auto(reduce_norm2, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3192 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3193 ccv_nnc_graph_exec_symbol_new(graph, reduce_norm2, inputs, input_size, outputs, output_size, "reduce_norm2");
3194}
3195
3196static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const self, void* const context);
3197
3198static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_norm2_isa = {
3199 .build = _ccv_cnnp_reduce_norm2_build,
3200 .copy = _ccv_cnnp_reduce_norm2_copy,
3201};
3202
3203ccv_cnnp_model_t* ccv_cnnp_reduce_norm2(const int* const axis, const int axis_count, const char* const name)
3204{
3205 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));
3206 model_reduce_norm2->super.isa = &ccv_cnnp_reduce_norm2_isa;
3207 model_reduce_norm2->super.input_size = 1;
3208 model_reduce_norm2->super.outputs = &model_reduce_norm2->output;
3209 model_reduce_norm2->super.output_size = 1;
3210 ccv_cnnp_model_copy_name(&model_reduce_norm2->super, name);
3211 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", 3211, __extension__ __PRETTY_FUNCTION__
); }));
3212 int i;
3213 for (i = 0; i < axis_count; i++)
3214 model_reduce_norm2->axis[i] = axis[i];
3215 model_reduce_norm2->count = axis_count;
3216 return (ccv_cnnp_model_t*)model_reduce_norm2;
3217}
3218
3219static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const super, void* const context)
3220{
3221 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
3222 return ccv_cnnp_reduce_norm2(self->axis, self->count, self->super.name);
3223}
3224
3225// MARK - Argmax Layer
3226
3227typedef struct {
3228 ccv_cnnp_model_t super;
3229 int axis;
3230 ccv_nnc_tensor_symbol_t output;
3231} ccv_cnnp_model_argmax_t;
3232
3233static 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)
3234{
3235 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
3236 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);
3237 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"
, 3237, __extension__ __PRETTY_FUNCTION__); }));
3238 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", 3238, __extension__ __PRETTY_FUNCTION__
); }));
3239 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3240 ccv_nnc_tensor_param_t output_params;
3241 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);
3242 argmax.info.reduce.axis[0] = self->axis;
3243 argmax.info.reduce.count = 1;
3244 ccv_nnc_hint_tensor_auto(argmax, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3245 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3246 ccv_nnc_graph_exec_symbol_new(graph, argmax, inputs, input_size, outputs, output_size, "argmax");
3247}
3248
3249static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const self, void* const context);
3250
3251static const ccv_cnnp_model_vtab_t ccv_cnnp_argmax_isa = {
3252 .build = _ccv_cnnp_argmax_build,
3253 .copy = _ccv_cnnp_argmax_copy,
3254};
3255
3256ccv_cnnp_model_t* ccv_cnnp_argmax(const int axis, const char* const name)
3257{
3258 ccv_cnnp_model_argmax_t* const model_argmax = (ccv_cnnp_model_argmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmax_t));
3259 model_argmax->super.isa = &ccv_cnnp_argmax_isa;
3260 model_argmax->super.input_size = 1;
3261 model_argmax->super.outputs = &model_argmax->output;
3262 model_argmax->super.output_size = 1;
3263 ccv_cnnp_model_copy_name(&model_argmax->super, name);
3264 model_argmax->axis = axis;
3265 return (ccv_cnnp_model_t*)model_argmax;
3266}
3267
3268static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const super, void* const context)
3269{
3270 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
3271 return ccv_cnnp_argmax(self->axis, self->super.name);
3272}
3273
3274// MARK - Argmin Layer
3275
3276typedef struct {
3277 ccv_cnnp_model_t super;
3278 int axis;
3279 ccv_nnc_tensor_symbol_t output;
3280} ccv_cnnp_model_argmin_t;
3281
3282static 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)
3283{
3284 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
3285 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);
3286 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"
, 3286, __extension__ __PRETTY_FUNCTION__); }));
3287 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", 3287, __extension__ __PRETTY_FUNCTION__
); }));
3288 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3289 ccv_nnc_tensor_param_t output_params;
3290 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);
3291 argmin.info.reduce.axis[0] = self->axis;
3292 argmin.info.reduce.count = 1;
3293 ccv_nnc_hint_tensor_auto(argmin, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3294 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3295 ccv_nnc_graph_exec_symbol_new(graph, argmin, inputs, input_size, outputs, output_size, "argmin");
3296}
3297
3298static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const self, void* const context);
3299
3300static const ccv_cnnp_model_vtab_t ccv_cnnp_argmin_isa = {
3301 .build = _ccv_cnnp_argmin_build,
3302 .copy = _ccv_cnnp_argmin_copy,
3303};
3304
3305ccv_cnnp_model_t* ccv_cnnp_argmin(const int axis, const char* const name)
3306{
3307 ccv_cnnp_model_argmin_t* const model_argmin = (ccv_cnnp_model_argmin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmin_t));
3308 model_argmin->super.isa = &ccv_cnnp_argmin_isa;
3309 model_argmin->super.input_size = 1;
3310 model_argmin->super.outputs = &model_argmin->output;
3311 model_argmin->super.output_size = 1;
3312 ccv_cnnp_model_copy_name(&model_argmin->super, name);
3313 model_argmin->axis = axis;
3314 return (ccv_cnnp_model_t*)model_argmin;
3315}
3316
3317static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const super, void* const context)
3318{
3319 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
3320 return ccv_cnnp_argmin(self->axis, self->super.name);
3321}
3322
3323// MARK - Min Layer
3324
3325typedef struct {
3326 ccv_cnnp_model_t super;
3327 ccv_nnc_tensor_symbol_t output;
3328} ccv_cnnp_model_min_t;
3329
3330static 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)
3331{
3332 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);
3333 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"
, 3333, __extension__ __PRETTY_FUNCTION__); }));
3334 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", 3334, __extension__ __PRETTY_FUNCTION__
); }));
3335 ccv_nnc_tensor_param_t input_params[2];
3336 int i;
3337 for (i = 0; i < 2; i++)
3338 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
3339 ccv_nnc_tensor_param_t output_params;
3340 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);
3341 ccv_nnc_hint_tensor_auto(min, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
3342 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3343 ccv_nnc_graph_exec_symbol_new(graph, min, inputs, input_size, outputs, output_size, "min");
3344}
3345
3346static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const self, void* const context);
3347
3348static const ccv_cnnp_model_vtab_t ccv_cnnp_min_isa = {
3349 .build = _ccv_cnnp_min_build,
3350 .copy = _ccv_cnnp_min_copy,
3351};
3352
3353ccv_cnnp_model_t* ccv_cnnp_min(const char* const name)
3354{
3355 ccv_cnnp_model_min_t* const model_min = (ccv_cnnp_model_min_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_min_t));
3356 model_min->super.isa = &ccv_cnnp_min_isa;
3357 model_min->super.input_size = 2;
3358 model_min->super.outputs = &model_min->output;
3359 model_min->super.output_size = 1;
3360 ccv_cnnp_model_copy_name(&model_min->super, name);
3361 return (ccv_cnnp_model_t*)model_min;
3362}
3363
3364static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const super, void* const context)
3365{
3366 const ccv_cnnp_model_min_t* const self = (const ccv_cnnp_model_min_t*)super;
3367 return ccv_cnnp_min(self->super.name);
3368}
3369
3370// MARK - Max Layer
3371
3372typedef struct {
3373 ccv_cnnp_model_t super;
3374 ccv_nnc_tensor_symbol_t output;
3375} ccv_cnnp_model_max_t;
3376
3377static 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)
3378{
3379 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);
3380 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"
, 3380, __extension__ __PRETTY_FUNCTION__); }));
3381 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", 3381, __extension__ __PRETTY_FUNCTION__
); }));
3382 ccv_nnc_tensor_param_t input_params[2];
3383 int i;
3384 for (i = 0; i < 2; i++)
3385 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
3386 ccv_nnc_tensor_param_t output_params;
3387 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);
3388 ccv_nnc_hint_tensor_auto(max, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
3389 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3390 ccv_nnc_graph_exec_symbol_new(graph, max, inputs, input_size, outputs, output_size, "max");
3391}
3392
3393static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const self, void* const context);
3394
3395static const ccv_cnnp_model_vtab_t ccv_cnnp_max_isa = {
3396 .build = _ccv_cnnp_max_build,
3397 .copy = _ccv_cnnp_max_copy,
3398};
3399
3400ccv_cnnp_model_t* ccv_cnnp_max(const char* const name)
3401{
3402 ccv_cnnp_model_max_t* const model_max = (ccv_cnnp_model_max_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_max_t));
3403 model_max->super.isa = &ccv_cnnp_max_isa;
3404 model_max->super.input_size = 2;
3405 model_max->super.outputs = &model_max->output;
3406 model_max->super.output_size = 1;
3407 ccv_cnnp_model_copy_name(&model_max->super, name);
3408 return (ccv_cnnp_model_t*)model_max;
3409}
3410
3411static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const super, void* const context)
3412{
3413 const ccv_cnnp_model_max_t* const self = (const ccv_cnnp_model_max_t*)super;
3414 return ccv_cnnp_max(self->super.name);
3415}
3416
3417// MARK - LSTM Layer
3418
3419typedef struct {
3420 ccv_cnnp_model_t super;
3421 int masked;
3422 ccv_nnc_tensor_symbol_t output;
3423 ccv_nnc_tensor_symbol_t weights;
3424 ccv_nnc_tensor_symbol_t reserves;
3425 ccv_nnc_cmd_param_t params;
3426 ccv_nnc_graph_exec_symbol_t lstm;
3427} ccv_cnnp_model_lstm_t;
3428
3429static int _ccv_cnnp_lstm_weight_dim(int bidirectional, int num_layers, int input_size, int hidden_size, int proj_size, int bias)
3430{
3431 const int D = !!bidirectional + 1;
3432 if (hidden_size == proj_size)
3433 return (num_layers * (bias ? 8 : 0) + (num_layers - 1) * (hidden_size * 4 * D + hidden_size * 4) + input_size * 4 + hidden_size * 4) * D;
3434 else
3435 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;
3436}
3437
3438static 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)
3439{
3440 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3441 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);
3442 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", 3442, __extension__ __PRETTY_FUNCTION__
); }));
3443 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", 3443, __extension__ __PRETTY_FUNCTION__
); }));
3444 const int proj_size = self->params.rnn.proj_size == 0 ? self->params.rnn.hidden_size : self->params.rnn.proj_size;
3445 ccv_nnc_tensor_param_t input_params[5];
3446 input_params[0]= ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3447 if (input_size == 2)
3448 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3449 input_params[4] = input_params[0];
3450 memset(input_params[4].dim, 0, sizeof(input_params[4].dim));
3451 const int x_nd = ccv_nnc_tensor_nd(input_params[0].dim);
3452 const int feature_count = input_params[0].dim[x_nd - 1];
3453 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);
3454 input_params[4].dim[1] = self->params.rnn.hidden_size;
3455 const ccv_nnc_cmd_t lstm = ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0);
3456 ccv_nnc_tensor_param_t output_params[4];
3457 ccv_nnc_hint_tensor_auto(lstm, input_params, 5, ccv_nnc_no_hint, output_params, 4);
3458 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3459 if (!self->weights.graph)
3460 self->weights = ccv_nnc_tensor_symbol_new(graph, input_params[4], "weights");
3461 if (!self->reserves.graph)
3462 self->reserves = ccv_nnc_tensor_symbol_new(graph, output_params[3], "reserves");
3463 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
};
3464 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");
3465}
3466
3467static 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)
3468{
3469 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3470 if (self->weights.graph)
3471 {
3472 const float stdv = 1.0 / sqrt(self->params.rnn.hidden_size);
3473 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);
3474 }
3475}
3476
3477static 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)
3478{
3479 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3480 if (self->weights.graph)
3481 add_to_array(parameters, self->weights, is_trainable);
3482}
3483
3484static 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)
3485{
3486 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
3487 if (self->lstm.graph)
3488 {
3489 self->params.rnn.is_test = is_test;
3490 updater(context, self->lstm, ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
3491 }
3492}
3493
3494static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const self, void* const context);
3495
3496static const ccv_cnnp_model_vtab_t ccv_cnnp_lstm_isa = {
3497 .build = _ccv_cnnp_lstm_build,
3498 .init_states = _ccv_cnnp_lstm_init_states,
3499 .add_to_parameter = _ccv_cnnp_lstm_add_to_parameter,
3500 .copy = _ccv_cnnp_lstm_copy,
3501 .set_is_test = _ccv_cnnp_lstm_set_is_test,
3502};
3503
3504ccv_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)
3505{
3506 ccv_cnnp_model_lstm_t* const model_lstm = (ccv_cnnp_model_lstm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_lstm_t));
3507 model_lstm->super.isa = &ccv_cnnp_lstm_isa;
3508 model_lstm->super.input_size = masked ? 2 : 1;
3509 model_lstm->super.outputs = &model_lstm->output;
3510 model_lstm->super.output_size = 1;
3511 model_lstm->super.is_trainable = is_trainable;
3512 ccv_cnnp_model_copy_name(&model_lstm->super, name);
3513 model_lstm->masked = masked;
3514 model_lstm->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
3515 model_lstm->weights.graph = 0;
3516 model_lstm->params.rnn.hidden_size = hidden_size;
3517 model_lstm->params.rnn.proj_size = proj_size;
3518 model_lstm->params.rnn.num_layers = num_layers;
3519 model_lstm->params.rnn.bias = bias;
3520 model_lstm->params.rnn.batch_first = batch_first;
3521 model_lstm->params.rnn.bidirectional = bidirectional;
3522 model_lstm->params.rnn.dropout = dropout;
3523 return (ccv_cnnp_model_t*)model_lstm;
3524}
3525
3526static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const super, void* const context)
3527{
3528 const ccv_cnnp_model_lstm_t* const self = (const ccv_cnnp_model_lstm_t*)super;
3529 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);
3530}
3531
3532/// MARK - Datatype conversion layer.
3533
3534typedef struct {
3535 ccv_cnnp_model_t super;
3536 ccv_nnc_tensor_symbol_t output;
3537 int datatype;
3538 int ref_to_last;
3539} ccv_cnnp_model_datatype_conversion_t;
3540
3541static 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)
3542{
3543 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
3544 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);
3545 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3546 if (self->ref_to_last)
3547 {
3548 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", 3548, __extension__ __PRETTY_FUNCTION__
); }));
3549 const ccv_nnc_tensor_param_t last_params = ccv_nnc_tensor_symbol_params(graph, inputs[input_size - 1]);
3550 params.datatype = last_params.datatype;
3551 } else
3552 params.datatype = self->datatype;
3553 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", 3553, __extension__ __PRETTY_FUNCTION__
); }));
3554 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3555 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 /* intentional */, outputs, output_size, 0);
3556}
3557
3558static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const self, void* const context);
3559
3560static const ccv_cnnp_model_vtab_t ccv_cnnp_datatype_conversion_isa = {
3561 .build = _ccv_cnnp_datatype_conversion_build,
3562 .copy = _ccv_cnnp_datatype_conversion_copy,
3563};
3564
3565ccv_cnnp_model_t* ccv_cnnp_datatype_conversion(const int datatype, const int ref_to_last, const char* const name)
3566{
3567 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));
3568 model_datatype_conversion->super.isa = &ccv_cnnp_datatype_conversion_isa;
3569 model_datatype_conversion->super.input_size = 0;
3570 model_datatype_conversion->super.outputs = &model_datatype_conversion->output;
3571 model_datatype_conversion->super.output_size = 1;
3572 model_datatype_conversion->datatype = datatype;
3573 model_datatype_conversion->ref_to_last = ref_to_last;
3574 ccv_cnnp_model_copy_name(&model_datatype_conversion->super, name);
3575 return (ccv_cnnp_model_t*)model_datatype_conversion;
3576}
3577
3578static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const super, void* const context)
3579{
3580 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
3581 return ccv_cnnp_datatype_conversion(self->datatype, self->ref_to_last, self->super.name);
3582}
3583
3584/// MARK - Clamp layer.
3585
3586typedef struct {
3587 ccv_cnnp_model_t super;
3588 ccv_nnc_tensor_symbol_t output;
3589 float min;
3590 float max;
3591} ccv_cnnp_model_clamp_t;
3592
3593static 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)
3594{
3595 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
3596 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);
3597 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3598 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", 3598, __extension__ __PRETTY_FUNCTION__
); }));
3599 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3600 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 /* intentional */, outputs, output_size, 0);
3601}
3602
3603static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const self, void* const context);
3604
3605static const ccv_cnnp_model_vtab_t ccv_cnnp_clamp_isa = {
3606 .build = _ccv_cnnp_clamp_build,
3607 .copy = _ccv_cnnp_clamp_copy,
3608};
3609
3610ccv_cnnp_model_t* ccv_cnnp_clamp(const float min, const float max, const char* const name)
3611{
3612 ccv_cnnp_model_clamp_t* const model_clamp = (ccv_cnnp_model_clamp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_clamp_t));
3613 model_clamp->super.isa = &ccv_cnnp_clamp_isa;
3614 model_clamp->super.input_size = 0;
3615 model_clamp->super.outputs = &model_clamp->output;
3616 model_clamp->super.output_size = 1;
3617 model_clamp->min = min;
3618 model_clamp->max = max;
3619 ccv_cnnp_model_copy_name(&model_clamp->super, name);
3620 return (ccv_cnnp_model_t*)model_clamp;
3621}
3622
3623static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const super, void* const context)
3624{
3625 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
3626 return ccv_cnnp_clamp(self->min, self->max, self->super.name);
3627}
3628
3629// MARK - Parameter Layer
3630
3631typedef struct {
3632 ccv_cnnp_model_t super;
3633 float init_bound;
3634 ccv_nnc_tensor_symbol_t weights;
3635 ccv_nnc_tensor_param_t weights_params;
3636 ccv_nnc_tensor_symbol_t output;
3637} ccv_cnnp_model_parameter_t;
3638
3639static 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)
3640{
3641 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);
3642 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", 3642, __extension__ __PRETTY_FUNCTION__
); }));
3643 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3644 if (!self->weights.graph)
3645 self->weights = ccv_nnc_tensor_symbol_new(graph, self->weights_params, "weights");
3646 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"
, 3646, __extension__ __PRETTY_FUNCTION__); }));
3647 outputs[0] = self->weights;
3648}
3649
3650static 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)
3651{
3652 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3653 if (self->init_bound > 0)
3654 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);
3655 else
3656 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);
3657}
3658
3659static 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)
3660{
3661 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
3662 add_to_array(parameters, self->weights, is_trainable);
3663}
3664
3665static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context);
3666
3667static const ccv_cnnp_model_vtab_t ccv_cnnp_parameter_isa = {
3668 .build = _ccv_cnnp_parameter_build,
3669 .init_states = _ccv_cnnp_parameter_init_states,
3670 .add_to_parameter = _ccv_cnnp_parameter_add_to_parameter,
3671 .copy = _ccv_cnnp_parameter_copy,
3672};
3673
3674ccv_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)
3675{
3676 ccv_cnnp_model_parameter_t* const model_parameter = (ccv_cnnp_model_parameter_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_parameter_t));
3677 model_parameter->super.isa = &ccv_cnnp_parameter_isa;
3678 model_parameter->super.input_size = 0;
3679 model_parameter->super.outputs = &model_parameter->output;
3680 model_parameter->super.output_size = 1;
3681 model_parameter->super.is_trainable = is_trainable;
3682 ccv_cnnp_model_copy_name(&model_parameter->super, name);
3683 model_parameter->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
3684 model_parameter->weights.graph = 0;
3685 model_parameter->weights_params = params;
3686 return (ccv_cnnp_model_t*)model_parameter;
3687}
3688
3689static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context)
3690{
3691 const ccv_cnnp_model_parameter_t* const self = (const ccv_cnnp_model_parameter_t*)super;
3692 return ccv_cnnp_parameter(self->weights_params, self->init_bound, self->super.is_trainable, self->super.name);
3693}
3694
3695// MARK - Scalar Layer
3696
3697typedef struct {
3698 ccv_cnnp_model_t super;
3699 int type;
3700 int format;
3701 int datatype;
3702 float value;
3703 ccv_nnc_tensor_symbol_t output;
3704} ccv_cnnp_model_scalar_t;
3705
3706static 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)
3707{
3708 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);
3709 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", 3709, __extension__ __PRETTY_FUNCTION__
); }));
3710 ccv_cnnp_model_scalar_t* const self = (ccv_cnnp_model_scalar_t*)super;
3711 ccv_nnc_tensor_param_t params = {
3712 .type = self->type,
3713 .format = self->format,
3714 .datatype = self->datatype,
3715 .dim = {
3716 1
3717 }
3718 };
3719 if (input_size > 0)
3720 {
3721 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3722 params.type = input_params.type;
3723 params.format = input_params.format;
3724 params.datatype = input_params.datatype;
3725 }
3726 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3727 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);
3728}
3729
3730static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context);
3731
3732static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_isa = {
3733 .build = _ccv_cnnp_scalar_build,
3734 .copy = _ccv_cnnp_scalar_copy,
3735};
3736
3737ccv_cnnp_model_t* ccv_cnnp_scalar(const int type, const int format, const int datatype, const float value, const char* const name)
3738{
3739 ccv_cnnp_model_scalar_t* const model_scalar = (ccv_cnnp_model_scalar_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scalar_t));
3740 model_scalar->super.isa = &ccv_cnnp_scalar_isa;
3741 model_scalar->super.input_size = 0;
3742 model_scalar->super.outputs = &model_scalar->output;
3743 model_scalar->super.output_size = 1;
3744 ccv_cnnp_model_copy_name(&model_scalar->super, name);
3745 model_scalar->type = type;
3746 model_scalar->format = format;
3747 model_scalar->datatype = datatype;
3748 model_scalar->value = value;
3749 return (ccv_cnnp_model_t*)model_scalar;
3750}
3751
3752static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context)
3753{
3754 const ccv_cnnp_model_scalar_t* const self = (const ccv_cnnp_model_scalar_t*)super;
3755 return ccv_cnnp_scalar(self->type, self->format, self->datatype, self->value, self->super.name);
3756}
3757
3758// MARK - Variable Layer
3759
3760typedef struct {
3761 ccv_cnnp_model_t super;
3762 ccv_nnc_tensor_param_t params;
3763 ccv_nnc_tensor_symbol_t output;
3764} ccv_cnnp_model_variable_t;
3765
3766static 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)
3767{
3768 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);
3769 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"
, 3769, __extension__ __PRETTY_FUNCTION__); }));
3770 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", 3770, __extension__ __PRETTY_FUNCTION__
); }));
3771 ccv_cnnp_model_variable_t* const self = (ccv_cnnp_model_variable_t*)super;
3772 outputs[0] = ccv_nnc_tensor_symbol_new(graph, self->params, 0);
3773}
3774
3775static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context);
3776
3777static const ccv_cnnp_model_vtab_t ccv_cnnp_variable_isa = {
3778 .build = _ccv_cnnp_variable_build,
3779 .copy = _ccv_cnnp_variable_copy,
3780};
3781
3782ccv_cnnp_model_t* ccv_cnnp_variable(const ccv_nnc_tensor_param_t params, const char* const name)
3783{
3784 ccv_cnnp_model_variable_t* const model_variable = (ccv_cnnp_model_variable_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_variable_t));
3785 model_variable->super.isa = &ccv_cnnp_variable_isa;
3786 model_variable->super.input_size = 0;
3787 model_variable->super.outputs = &model_variable->output;
3788 model_variable->super.output_size = 1;
3789 ccv_cnnp_model_copy_name(&model_variable->super, name);
3790 model_variable->params = params;
3791 return (ccv_cnnp_model_t*)model_variable;
3792}
3793
3794static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context)
3795{
3796 const ccv_cnnp_model_variable_t* const self = (const ccv_cnnp_model_variable_t*)super;
3797 return ccv_cnnp_variable(self->params, self->super.name);
3798}
3799
3800// MARK - Move Layer
3801
3802typedef struct {
3803 ccv_cnnp_model_t super;
3804 ccv_nnc_tensor_symbol_t output;
3805} ccv_cnnp_model_move_t;
3806
3807static 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)
3808{
3809 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);
3810 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"
, 3810, __extension__ __PRETTY_FUNCTION__); }));
3811 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", 3811, __extension__ __PRETTY_FUNCTION__
); }));
3812 outputs[0] = inputs[1];
3813 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");
3814}
3815
3816static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context);
3817
3818static const ccv_cnnp_model_vtab_t ccv_cnnp_move_isa = {
3819 .build = _ccv_cnnp_move_build,
3820 .copy = _ccv_cnnp_move_copy,
3821};
3822
3823ccv_cnnp_model_t* ccv_cnnp_move(const char* const name)
3824{
3825 ccv_cnnp_model_move_t* const model_move = (ccv_cnnp_model_move_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_move_t));
3826 model_move->super.isa = &ccv_cnnp_move_isa;
3827 model_move->super.input_size = 2;
3828 model_move->super.outputs = &model_move->output;
3829 model_move->super.output_size = 1;
3830 ccv_cnnp_model_copy_name(&model_move->super, name);
3831 return (ccv_cnnp_model_t*)model_move;
3832}
3833
3834static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context)
3835{
3836 const ccv_cnnp_model_move_t* const self = (const ccv_cnnp_model_move_t*)super;
3837 return ccv_cnnp_move(self->super.name);
3838}
3839
3840// MARK - "Making" Contiguous Layer
3841
3842typedef struct {
3843 ccv_cnnp_model_t super;
3844 ccv_nnc_tensor_symbol_t output;
3845} ccv_cnnp_model_contiguous_t;
3846
3847static 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)
3848{
3849 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);
3850 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"
, 3850, __extension__ __PRETTY_FUNCTION__); }));
3851 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", 3851, __extension__ __PRETTY_FUNCTION__
); }));
3852 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3853 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
3854 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
3855 {
3856 outputs[0] = inputs[0];
3857 return;
3858 }
3859 // Otherwise, we need to check its stride to know if it is contiguous.
3860 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
3861 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
3862 // We identify permute by checking if the stride is not in descending order.
3863 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
3864 if (ccv_nnc_is_tensor_stride_packed(old_stride, params.dim))
3865 {
3866 outputs[0] = inputs[0];
3867 return;
3868 }
3869 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3870 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");
3871 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
3872}
3873
3874static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context);
3875
3876static const ccv_cnnp_model_vtab_t ccv_cnnp_contiguous_isa = {
3877 .build = _ccv_cnnp_contiguous_build,
3878 .copy = _ccv_cnnp_contiguous_copy,
3879};
3880
3881ccv_cnnp_model_t* ccv_cnnp_contiguous(const char* const name)
3882{
3883 ccv_cnnp_model_contiguous_t* const model_contiguous = (ccv_cnnp_model_contiguous_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_contiguous_t));
3884 model_contiguous->super.isa = &ccv_cnnp_contiguous_isa;
3885 model_contiguous->super.input_size = 1;
3886 model_contiguous->super.outputs = &model_contiguous->output;
3887 model_contiguous->super.output_size = 1;
3888 ccv_cnnp_model_copy_name(&model_contiguous->super, name);
3889 return (ccv_cnnp_model_t*)model_contiguous;
3890}
3891
3892static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context)
3893{
3894 const ccv_cnnp_model_contiguous_t* const self = (const ccv_cnnp_model_contiguous_t*)super;
3895 return ccv_cnnp_contiguous(self->super.name);
3896}
3897
3898// MARK - "Making" Copy Layer
3899
3900typedef struct {
3901 ccv_cnnp_model_t super;
3902 ccv_nnc_tensor_symbol_t output;
3903} ccv_cnnp_model_copy_t;
3904
3905static 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)
3906{
3907 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);
3908 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"
, 3908, __extension__ __PRETTY_FUNCTION__); }));
3909 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", 3909, __extension__ __PRETTY_FUNCTION__
); }));
3910 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3911 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
3912 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
3913 {
3914 outputs[0] = inputs[0];
3915 return;
3916 }
3917 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
3918 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");
3919 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
3920}
3921
3922static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context);
3923
3924static const ccv_cnnp_model_vtab_t ccv_cnnp_copy_isa = {
3925 .build = _ccv_cnnp_copy_build,
3926 .copy = _ccv_cnnp_copy_copy,
3927};
3928
3929ccv_cnnp_model_t* ccv_cnnp_copy(const char* const name)
3930{
3931 ccv_cnnp_model_copy_t* const model_copy = (ccv_cnnp_model_copy_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_copy_t));
3932 model_copy->super.isa = &ccv_cnnp_copy_isa;
3933 model_copy->super.input_size = 1;
3934 model_copy->super.outputs = &model_copy->output;
3935 model_copy->super.output_size = 1;
3936 ccv_cnnp_model_copy_name(&model_copy->super, name);
3937 return (ccv_cnnp_model_t*)model_copy;
3938}
3939
3940static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context)
3941{
3942 const ccv_cnnp_model_copy_t* const self = (const ccv_cnnp_model_copy_t*)super;
3943 return ccv_cnnp_copy(self->super.name);
3944}
3945
3946// MARK - Scaled-Dot Product Attention Layer
3947
3948typedef struct {
3949 ccv_cnnp_model_t super;
3950 ccv_nnc_tensor_symbol_t output;
3951 ccv_nnc_tensor_symbol_t weights;
3952 ccv_nnc_tensor_symbol_t bias;
3953 float scale;
3954 int is_causal;
3955 int has_attn_mask;
3956 int flags;
3957 int fused_unify_head_weights;
3958 int no_bias;
3959} ccv_cnnp_model_scaled_dot_product_attention_t;
3960
3961static 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)
3962{
3963 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);
3964 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"
, 3964, __extension__ __PRETTY_FUNCTION__); }));
3965 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", 3965, __extension__ __PRETTY_FUNCTION__
); }));
3966 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
3967 const ccv_nnc_tensor_param_t q_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3968 const ccv_nnc_tensor_param_t k_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3969 const ccv_nnc_tensor_param_t v_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
3970 const int v_nd = ccv_nnc_tensor_nd(v_params.dim);
3971 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", 3971, __extension__ __PRETTY_FUNCTION__
); }));
3972 const int hEv = (v_nd == 3 ? 1 : v_params.dim[2]) * v_params.dim[v_nd - 1];
3973 ccv_nnc_tensor_param_t weights_params = q_params;
3974 memset(weights_params.dim, 0, sizeof(weights_params.dim));
3975 weights_params.dim[0] = hEv;
3976 weights_params.dim[1] = hEv;
3977 ccv_nnc_tensor_param_t bias_params = q_params;
3978 memset(bias_params.dim, 0, sizeof(bias_params.dim));
3979 bias_params.dim[0] = hEv;
3980 ccv_nnc_cmd_t cmd = {0};
3981 cmd.cmd = CCV_NNC_SCALED_DOT_PRODUCT_ATTENTION_FORWARD;
3982 cmd.info.scaled_dot_product_attention.scale = self->scale;
3983 cmd.info.scaled_dot_product_attention.is_causal = self->is_causal;
3984 cmd.info.scaled_dot_product_attention.flags = self->flags;
3985 ccv_nnc_tensor_param_t output_params[3];
3986 ccv_nnc_tensor_symbol_t output;
3987 ccv_nnc_tensor_symbol_t saved_softmax_lse;
3988 ccv_nnc_tensor_symbol_t saved_v_proj = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3989 ccv_nnc_tensor_symbol_t attn_mask = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3990 ccv_nnc_tensor_symbol_t weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3991 ccv_nnc_tensor_symbol_t bias = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3992 if (self->has_attn_mask)
3993 attn_mask = inputs[3];
3994 if (self->fused_unify_head_weights)
3995 {
3996 if (!self->weights.graph)
3997 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
3998 weights = self->weights;
3999 if (!self->no_bias)
4000 {
4001 if (!self->bias.graph)
4002 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
4003 bias = self->bias;
4004 }
4005 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
4006 q_params,
4007 k_params,
4008 v_params,
4009 (ccv_nnc_tensor_param_t){},
4010 weights_params,
4011 bias_params,
4012 }, 6, ccv_nnc_no_hint, output_params, 3);
4013 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4014 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4015 saved_v_proj = ccv_nnc_tensor_symbol_new(graph, output_params[2], 0);
4016 } else {
4017 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
4018 q_params,
4019 k_params,
4020 v_params,
4021 }, 3, ccv_nnc_no_hint, output_params, 2);
4022 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4023 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4024 }
4025 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");
4026 outputs[0] = output;
4027}
4028
4029static 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)
4030{
4031 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4032 if (self->weights.graph)
4033 {
4034 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"
, 4034, __extension__ __PRETTY_FUNCTION__); }));
4035 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
4036 const int c = weight_params.dim[1];
4037 const float std = sqrtf(2) / sqrtf(c);
4038 const float bound = sqrtf(3) * std;
4039 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);
4040 if (self->bias.graph)
4041 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);
4042 }
4043}
4044
4045static 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)
4046{
4047 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4048 if (self->weights.graph)
4049 {
4050 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"
, 4050, __extension__ __PRETTY_FUNCTION__); }));
4051 add_to_array(parameters, self->weights, is_trainable);
4052 if (self->bias.graph)
4053 add_to_array(parameters, self->bias, is_trainable);
4054 }
4055}
4056
4057static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context);
4058
4059static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_isa = {
4060 .build = _ccv_cnnp_scaled_dot_product_attention_build,
4061 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
4062};
4063
4064static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_fused_isa = {
4065 .build = _ccv_cnnp_scaled_dot_product_attention_build,
4066 .init_states = _ccv_cnnp_scaled_dot_product_attention_init_states,
4067 .add_to_parameter = _ccv_cnnp_scaled_dot_product_attention_add_to_parameter,
4068 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
4069};
4070
4071ccv_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)
4072{
4073 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));
4074 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;
4075 model_scaled_dot_product_attention->super.input_size = has_attn_mask ? 4 : 3;
4076 model_scaled_dot_product_attention->super.outputs = &model_scaled_dot_product_attention->output;
4077 model_scaled_dot_product_attention->super.output_size = 1;
4078 model_scaled_dot_product_attention->super.is_trainable = is_trainable;
4079 ccv_cnnp_model_copy_name(&model_scaled_dot_product_attention->super, name);
4080 model_scaled_dot_product_attention->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4081 model_scaled_dot_product_attention->weights.graph = 0;
4082 model_scaled_dot_product_attention->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
4083 model_scaled_dot_product_attention->bias.graph = 0;
4084 model_scaled_dot_product_attention->scale = scale;
4085 model_scaled_dot_product_attention->is_causal = is_causal;
4086 model_scaled_dot_product_attention->has_attn_mask = has_attn_mask;
4087 model_scaled_dot_product_attention->flags = flags;
4088 model_scaled_dot_product_attention->fused_unify_head_weights = fused_unify_head_weights;
4089 model_scaled_dot_product_attention->no_bias = no_bias;
4090 return (ccv_cnnp_model_t*)model_scaled_dot_product_attention;
4091}
4092
4093static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context)
4094{
4095 const ccv_cnnp_model_scaled_dot_product_attention_t* const self = (const ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4096 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);
4097}
4098
4099// MARK - Debug Layer
4100
4101typedef struct {
4102 ccv_cnnp_model_t super;
4103 ccv_nnc_tensor_symbol_t output;
4104 ccv_cnnp_model_debug_f debugger;
4105 ccv_cnnp_model_debug_context_deinit_f debug_deinit;
4106 ccv_cnnp_model_debug_context_copy_f debug_copy;
4107 void* debug_context;
4108} ccv_cnnp_model_debug_t;
4109
4110static 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)
4111{
4112 if (cmd.cmd == CCV_NNC_CUSTOM_BACKWARD)
4113 {
4114 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", 4114, __extension__ __PRETTY_FUNCTION__
); }));
4115 }
4116 ccv_cnnp_model_debug_t* const self = (ccv_cnnp_model_debug_t*)cmd.data;
4117 self->debugger(inputs, input_size, stream_context, self->debug_context);
4118 return CCV_NNC_EXEC_SUCCESS;
4119}
4120
4121static ccv_nnc_cmd_vtab_t ccv_cnnp_debug_exec_isa = {
4122 .exec = _ccv_cnnp_debug_exec
4123};
4124
4125static 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)
4126{
4127 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);
4128 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", 4128, __extension__ __PRETTY_FUNCTION__
); }));
4129 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", 4129, __extension__ __PRETTY_FUNCTION__
); }));
4130 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
4131 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4132 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
4133 {
4134 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {0};
4135 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4136 ccv_nnc_tensor_get_stride(output_params.dim, stride);
4137 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
4138 } else {
4139 int old_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
4140 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4141 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], old_ofs, old_stride);
4142 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, to, old_ofs, old_stride, output_params, 0);
4143 }
4144 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);
4145 cmd.data = self;
4146 ccv_nnc_graph_exec_symbol_t make_debug = ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, input_size, outputs, 1, "debug");
4147 // Disable any optimizations.
4148 ccv_nnc_graph_exec_symbol_set_flags(graph, make_debug, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
4149}
4150
4151static void _ccv_cnnp_debug_deinit(ccv_cnnp_model_t* const super)
4152{
4153 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
4154 if (self->debug_deinit && self->debug_context)
4155 self->debug_deinit(self->debug_context);
4156}
4157
4158static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context);
4159
4160static const ccv_cnnp_model_vtab_t ccv_cnnp_debug_isa = {
4161 .build = _ccv_cnnp_debug_build,
4162 .deinit = _ccv_cnnp_debug_deinit,
4163 .copy = _ccv_cnnp_debug_copy,
4164};
4165
4166ccv_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)
4167{
4168 ccv_cnnp_model_debug_t* const model_debug = (ccv_cnnp_model_debug_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_debug_t));
4169 model_debug->super.isa = &ccv_cnnp_debug_isa;
4170 model_debug->super.input_size = 0;
4171 model_debug->super.outputs = &model_debug->output;
4172 model_debug->super.output_size = 1;
4173 model_debug->debugger = func;
4174 model_debug->debug_context = context;
4175 model_debug->debug_deinit = deinit;
4176 model_debug->debug_copy = copy;
4177 ccv_cnnp_model_copy_name(&model_debug->super, name);
4178 return (ccv_cnnp_model_t*)model_debug;
4179}
4180
4181static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context)
4182{
4183 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
4184 void* debug_context = self->debug_context;
4185 if (self->debug_copy && self->debug_context)
4186 debug_context = self->debug_copy(self->debug_context);
4187 return ccv_cnnp_debug(self->debugger, debug_context, self->debug_deinit, self->debug_copy, self->super.name);
4188}
4189
4190/// MARK - Sort layer.
4191
4192typedef struct {
4193 ccv_cnnp_model_t super;
4194 ccv_nnc_tensor_symbol_t outputs[2];
4195 int along_axis;
4196 int descending;
4197} ccv_cnnp_model_sort_t;
4198
4199static void _ccv_cnnp_sort_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)
4200{
4201 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
4202 PRINT(CCV_CLI_VERBOSE, "[cnnp_sort_build] - along_axis: %d, descending: %d\n", self->along_axis, self->descending)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sort_build] - along_axis: %d, descending: %d\n"
, self->along_axis, self->descending); fflush(stdout); }
} while (0);
4203 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4204 assert(output_size == 2)((void) sizeof ((output_size == 2) ? 1 : 0), __extension__ ({
if (output_size == 2) ; else __assert_fail ("output_size == 2"
, "ccv_cnnp_model_addons.c", 4204, __extension__ __PRETTY_FUNCTION__
); }));
4205 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4206 params.datatype = CCV_32S;
4207 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4208 ccv_nnc_graph_exec_symbol_new(graph, CMD_SORT_FORWARD(self->along_axis, self->descending)ccv_nnc_cmd(CCV_NNC_SORT_FORWARD, 0, ((ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.sort={.along_axis=self->along_axis,.descending
=self->descending}}), 0), inputs, input_size, outputs, output_size, "sort");
4209}
4210
4211static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const self, void* const context);
4212
4213static const ccv_cnnp_model_vtab_t ccv_cnnp_sort_isa = {
4214 .build = _ccv_cnnp_sort_build,
4215 .copy = _ccv_cnnp_sort_copy,
4216};
4217
4218ccv_cnnp_model_t* ccv_cnnp_sort(const int along_axis, const int descending, const char* const name)
4219{
4220 ccv_cnnp_model_sort_t* const model_sort = (ccv_cnnp_model_sort_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sort_t));
4221 model_sort->super.isa = &ccv_cnnp_sort_isa;
4222 model_sort->super.input_size = 0;
4223 model_sort->super.outputs = model_sort->outputs;
4224 model_sort->super.output_size = 2;
4225 model_sort->along_axis = along_axis;
4226 model_sort->descending = descending;
4227 ccv_cnnp_model_copy_name(&model_sort->super, name);
4228 return (ccv_cnnp_model_t*)model_sort;
4229}
4230
4231static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const super, void* const context)
4232{
4233 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
4234 return ccv_cnnp_sort(self->along_axis, self->descending, self->super.name);
4235}
4236
4237/// MARK - Partition layer.
4238
4239typedef struct {
4240 ccv_cnnp_model_t super;
4241 ccv_nnc_tensor_symbol_t outputs[2];
4242 int kth;
4243 int along_axis;
4244 int descending;
4245} ccv_cnnp_model_partition_t;
4246
4247static void _ccv_cnnp_partition_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)
4248{
4249 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
4250 PRINT(CCV_CLI_VERBOSE, "[cnnp_partition_build] - kth: %d, along_axis: %d, descending: %d\n", self->kth, self->along_axis, self->descending)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_partition_build] - kth: %d, along_axis: %d, descending: %d\n"
, self->kth, self->along_axis, self->descending); fflush
(stdout); } } while (0);
4251 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4252 assert(output_size == 2)((void) sizeof ((output_size == 2) ? 1 : 0), __extension__ ({
if (output_size == 2) ; else __assert_fail ("output_size == 2"
, "ccv_cnnp_model_addons.c", 4252, __extension__ __PRETTY_FUNCTION__
); }));
4253 if (self->kth > 0)
4254 params.dim[self->along_axis] = self->kth;
4255 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4256 params.datatype = CCV_32S;
4257 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4258 ccv_nnc_graph_exec_symbol_new(graph, CMD_PARTITION_FORWARD(self->kth, self->along_axis, self->descending)ccv_nnc_cmd(CCV_NNC_PARTITION_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.partition={.kth=self->kth,.along_axis
=self->along_axis,.descending=self->descending}}), 0), inputs, input_size, outputs, output_size, "partition");
4259}
4260
4261static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const self, void* const context);
4262
4263static const ccv_cnnp_model_vtab_t ccv_cnnp_partition_isa = {
4264 .build = _ccv_cnnp_partition_build,
4265 .copy = _ccv_cnnp_partition_copy,
4266};
4267
4268ccv_cnnp_model_t* ccv_cnnp_partition(const int kth, const int along_axis, const int descending, const char* const name)
4269{
4270 ccv_cnnp_model_partition_t* const model_partition = (ccv_cnnp_model_partition_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_partition_t));
4271 model_partition->super.isa = &ccv_cnnp_partition_isa;
4272 model_partition->super.input_size = 0;
4273 model_partition->super.outputs = model_partition->outputs;
4274 model_partition->super.output_size = 2;
4275 model_partition->kth = kth;
4276 model_partition->along_axis = along_axis;
4277 model_partition->descending = descending;
4278 ccv_cnnp_model_copy_name(&model_partition->super, name);
4279 return (ccv_cnnp_model_t*)model_partition;
4280}
4281
4282static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const super, void* const context)
4283{
4284 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
4285 return ccv_cnnp_partition(self->kth, self->along_axis, self->descending, self->super.name);
4286}
4287
4288/// MARK - Unique consecutive layer.
4289
4290typedef struct {
4291 ccv_cnnp_model_t super;
4292 ccv_nnc_tensor_symbol_t outputs[2];
4293 int bincount;
4294} ccv_cnnp_model_unique_consecutive_t;
4295
4296static void _ccv_cnnp_unique_consecutive_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)
4297{
4298 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
4299 PRINT(CCV_CLI_VERBOSE, "[cnnp_unique_consecutive_build] - bincount: %d\n", self->bincount)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_unique_consecutive_build] - bincount: %d\n",
self->bincount); fflush(stdout); } } while (0);
4300 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4301 assert(output_size == 2)((void) sizeof ((output_size == 2) ? 1 : 0), __extension__ ({
if (output_size == 2) ; else __assert_fail ("output_size == 2"
, "ccv_cnnp_model_addons.c", 4301, __extension__ __PRETTY_FUNCTION__
); }));
4302 if (self->bincount > 0)
4303 params.dim[0] = ccv_min(params.dim[0], self->bincount)({ typeof (params.dim[0]) _a = (params.dim[0]); typeof (self->
bincount) _b = (self->bincount); (_a < _b) ? _a : _b; }
);
4304 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4305 params.datatype = CCV_32S;
4306 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4307 ccv_nnc_graph_exec_symbol_new(graph, CMD_UNIQUE_CONSECUTIVE_FORWARD(self->bincount)ccv_nnc_cmd(CCV_NNC_UNIQUE_CONSECUTIVE_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.unique_consecutive={.bincount=self->
bincount}}), 0), inputs, input_size, outputs, output_size, "unique_consecutive");
4308}
4309
4310static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const self, void* const context);
4311
4312static const ccv_cnnp_model_vtab_t ccv_cnnp_unique_consecutive_isa = {
4313 .build = _ccv_cnnp_unique_consecutive_build,
4314 .copy = _ccv_cnnp_unique_consecutive_copy,
4315};
4316
4317ccv_cnnp_model_t* ccv_cnnp_unique_consecutive(const int bincount, const char* const name)
4318{
4319 ccv_cnnp_model_unique_consecutive_t* const model_unique_consecutive = (ccv_cnnp_model_unique_consecutive_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_unique_consecutive_t));
4320 model_unique_consecutive->super.isa = &ccv_cnnp_unique_consecutive_isa;
4321 model_unique_consecutive->super.input_size = 0;
4322 model_unique_consecutive->super.outputs = model_unique_consecutive->outputs;
4323 model_unique_consecutive->super.output_size = 2;
4324 model_unique_consecutive->bincount = bincount;
4325 ccv_cnnp_model_copy_name(&model_unique_consecutive->super, name);
4326 return (ccv_cnnp_model_t*)model_unique_consecutive;
4327}
4328
4329static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const super, void* const context)
4330{
4331 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
4332 return ccv_cnnp_unique_consecutive(self->bincount, self->super.name);
4333}
4334
4335/// MARK - Scatter add layer.
4336
4337typedef struct {
4338 ccv_cnnp_model_t super;
4339 ccv_nnc_tensor_symbol_t output;
4340 int bincount;
4341} ccv_cnnp_model_scatter_add_t;
4342
4343static void _ccv_cnnp_scatter_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)
4344{
4345 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
4346 PRINT(CCV_CLI_VERBOSE, "[cnnp_scatter_add_build] - bincount: %d\n", self->bincount)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_scatter_add_build] - bincount: %d\n", self->
bincount); fflush(stdout); } } while (0);
4347 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4348 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", 4348, __extension__ __PRETTY_FUNCTION__
); }));
4349 assert(self->bincount > 0)((void) sizeof ((self->bincount > 0) ? 1 : 0), __extension__
({ if (self->bincount > 0) ; else __assert_fail ("self->bincount > 0"
, "ccv_cnnp_model_addons.c", 4349, __extension__ __PRETTY_FUNCTION__
); }));
4350 params.dim[0] = self->bincount;
4351 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4352 ccv_nnc_graph_exec_symbol_new(graph, CMD_SCATTER_ADD_FORWARD(self->bincount)ccv_nnc_cmd(CCV_NNC_SCATTER_ADD_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.scatter_add={.bincount=self->bincount
}}), 0), inputs, input_size, outputs, output_size, "scatter_add");
4353}
4354
4355static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const self, void* const context);
4356
4357static const ccv_cnnp_model_vtab_t ccv_cnnp_scatter_add_isa = {
4358 .build = _ccv_cnnp_scatter_add_build,
4359 .copy = _ccv_cnnp_scatter_add_copy,
4360};
4361
4362ccv_cnnp_model_t* ccv_cnnp_scatter_add(const int bincount, const char* const name)
4363{
4364 assert(bincount > 0)((void) sizeof ((bincount > 0) ? 1 : 0), __extension__ ({ if
(bincount > 0) ; else __assert_fail ("bincount > 0", "ccv_cnnp_model_addons.c"
, 4364, __extension__ __PRETTY_FUNCTION__); }));
4365 ccv_cnnp_model_scatter_add_t* const model_scatter_add = (ccv_cnnp_model_scatter_add_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scatter_add_t));
4366 model_scatter_add->super.isa = &ccv_cnnp_scatter_add_isa;
4367 model_scatter_add->super.input_size = 0;
4368 model_scatter_add->super.outputs = &model_scatter_add->output;
4369 model_scatter_add->super.output_size = 1;
4370 model_scatter_add->bincount = bincount;
4371 ccv_cnnp_model_copy_name(&model_scatter_add->super, name);
4372 return (ccv_cnnp_model_t*)model_scatter_add;
4373}
4374
4375static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const super, void* const context)
4376{
4377 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
4378 return ccv_cnnp_scatter_add(self->bincount, self->super.name);
4379}
4380
4381// MARK - Segmented Dense Layer
4382
4383typedef struct {
4384 ccv_cnnp_model_t super;
4385 ccv_nnc_tensor_symbol_t output;
4386 ccv_nnc_tensor_symbol_t weights;
4387 ccv_nnc_tensor_symbol_t bias;
4388 int segments;
4389 int count;
4390 int no_bias;
4391 int flags;
4392} ccv_cnnp_model_segmented_dense_t;
4393
4394static void _ccv_cnnp_segmented_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)
4395{
4396 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
4397 PRINT(CCV_CLI_VERBOSE, "[cnnp_segmented_dense_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_segmented_dense_build] -\n"); fflush(stdout)
; } } while (0);
4398 assert(input_size == 3)((void) sizeof ((input_size == 3) ? 1 : 0), __extension__ ({ if
(input_size == 3) ; else __assert_fail ("input_size == 3", "ccv_cnnp_model_addons.c"
, 4398, __extension__ __PRETTY_FUNCTION__); }));
4399 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", 4399, __extension__ __PRETTY_FUNCTION__
); }));
4400 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4401 const ccv_nnc_tensor_param_t indices_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
4402 const ccv_nnc_tensor_param_t counts_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
4403 ccv_nnc_tensor_param_t weights_params = params;
4404 memset(weights_params.dim, 0, sizeof(weights_params.dim));
4405 weights_params.dim[0] = self->segments;
4406 weights_params.dim[1] = self->count;
4407 weights_params.dim[2] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
4408 if (!self->weights.graph)
4409 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
4410 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"
, 4410, __extension__ __PRETTY_FUNCTION__); }));
4411 ccv_nnc_tensor_param_t bias_params = params;
4412 memset(bias_params.dim, 0, sizeof(bias_params.dim));
4413 bias_params.dim[0] = self->segments;
4414 bias_params.dim[1] = self->count;
4415 ccv_nnc_cmd_t cmd = {0};
4416 cmd.cmd = CCV_NNC_SEGMENTED_GEMM_FORWARD;
4417 cmd.info.blas.a[0] = 1;
4418 cmd.info.blas.a[1] = 1;
4419 cmd.info.blas.transpose_b[0] = 1;
4420 cmd.info.blas.transpose_b[1] = 2;
4421 cmd.info.blas.flags = self->flags;
4422 ccv_nnc_tensor_param_t output_params;
4423 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
4424 params, indices_params, counts_params,
4425 weights_params,
4426 bias_params,
4427 }, 5, ccv_nnc_no_hint, &output_params, 1);
4428 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4429 if (self->no_bias)
4430 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], self->weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], self->weights}, (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), 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), "segmented_dense");
4431 else {
4432 if (!self->bias.graph)
4433 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
4434 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], self->weights, self->bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], self->weights, self->bias}, (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)(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), "segmented_dense");
4435 }
4436 outputs[0] = output;
4437}
4438
4439static void _ccv_cnnp_segmented_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)
4440{
4441 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
4442 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
4443 const int c = weight_params.dim[1];
4444 const float std = sqrtf(2) / sqrtf(c);
4445 const float bound = sqrtf(3) * std;
4446 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);
4447 if (self->bias.graph)
4448 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);
4449}
4450
4451static void _ccv_cnnp_segmented_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)
4452{
4453 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
4454 add_to_array(parameters, self->weights, is_trainable);
4455 if (self->bias.graph)
4456 add_to_array(parameters, self->bias, is_trainable);
4457}
4458
4459static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
4460
4461static const ccv_cnnp_model_vtab_t ccv_cnnp_segmented_dense_isa = {
4462 .build = _ccv_cnnp_segmented_dense_build,
4463 .init_states = _ccv_cnnp_segmented_dense_init_states,
4464 .add_to_parameter = _ccv_cnnp_segmented_dense_add_to_parameter,
4465 .copy = _ccv_cnnp_segmented_dense_copy,
4466};
4467
4468ccv_cnnp_model_t* ccv_cnnp_segmented_dense(const int segments, const int count, const int no_bias, const int flags, const int is_trainable, const char* const name)
4469{
4470 ccv_cnnp_model_segmented_dense_t* const model_segmented_dense = (ccv_cnnp_model_segmented_dense_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_segmented_dense_t));
4471 model_segmented_dense->super.isa = &ccv_cnnp_segmented_dense_isa;
4472 model_segmented_dense->super.input_size = 3;
4473 model_segmented_dense->super.outputs = &model_segmented_dense->output;
4474 model_segmented_dense->super.output_size = 1;
4475 model_segmented_dense->super.is_trainable = is_trainable;
4476 ccv_cnnp_model_copy_name(&model_segmented_dense->super, name);
4477 model_segmented_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4478 model_segmented_dense->weights.graph = 0;
4479 model_segmented_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
4480 model_segmented_dense->bias.graph = 0;
4481 model_segmented_dense->segments = segments;
4482 model_segmented_dense->count = count;
4483 model_segmented_dense->no_bias = no_bias;
4484 model_segmented_dense->flags = flags;
4485 return (ccv_cnnp_model_t*)model_segmented_dense;
4486}
4487
4488static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
4489{
4490 const ccv_cnnp_model_segmented_dense_t* const self = (const ccv_cnnp_model_segmented_dense_t*)super;
4491 return ccv_cnnp_segmented_dense(self->segments, self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
4492}