Bug Summary

File:nnc/ccv_cnnp_model_addons.c
Warning:line 405, column 3
Declared variable-length array (VLA) has negative size

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/2026-08-10-115439-738049-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);
1
Assuming the condition is false
→
2
←
Taking false branch
→
3
←
Loop condition is false. Exiting loop
→
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__
); }));
4
←
Assuming 'output_size' is equal to 1
→
5
←
Taking true branch
→
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)
6
←
Assuming the condition is false
→
7
←
Taking false branch
→
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 if (nd > 0)
8
←
Assuming 'nd' is > 0
→
9
←
Taking true branch
→
368 {
369 assert(axis < nd)((void) sizeof ((axis < nd) ? 1 : 0), __extension__ ({ if (
axis < nd) ; else __assert_fail ("axis < nd", "ccv_cnnp_model_addons.c"
, 369, __extension__ __PRETTY_FUNCTION__); }));
10
←
Assuming 'axis' is < 'nd'
→
11
←
Taking true branch
→
370 output_params.dim[axis] = 0;
371 } else
372 for (i = 0; i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
373 output_params.dim[i] = 0;
374 int input_is_contiguous = 1;
375 for (i = 0; i < input_size; i++)
12
←
Assuming 'i' is >= 'input_size'
→
13
←
Loop condition is false. Execution continues on line 399
→
376 {
377 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
378 const int input_nd = ccv_nnc_tensor_nd(input_params.dim);
379 if (input_nd == 0)
380 {
381 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);
382 input_is_contiguous = 0;
383 continue;
384 }
385 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
386 {
387 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);
388 int i;
389 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && input_params.dim[i] > 0; i++)
390 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);
391 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
392 }
393 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"
, 393, __extension__ __PRETTY_FUNCTION__); }));
394 for (j = 0; j < nd; j++)
395 if (j != axis)
396 { 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", 396, __extension__ __PRETTY_FUNCTION__
); })); }
397 output_params.dim[axis] += input_params.dim[axis];
398 }
399 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
400 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
401 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
402 ccv_nnc_tensor_get_stride(output_params.dim, stride);
403 if (input_is_contiguous
13.1
'input_is_contiguous' is 1
)
14
←
Taking true branch
→
404 {
405 ccv_nnc_tensor_symbol_t aliases[input_size];
15
←
Declared variable-length array (VLA) has negative size
406 for (i = 0; i < input_size; i++)
407 {
408 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
409 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
410 ofs[axis] += input_params.dim[axis];
411 }
412 // Format transform is more flexible.
413 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");
414 } else {
415 ccv_nnc_tensor_symbol_t aliases[input_size];
416 for (i = 0; i < input_size; i++)
417 {
418 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
419 if (input_params.dim[0] == 0)
420 {
421 // Create a new alias anyway, but not going to use it, in this way, the alias count will match during absorb.
422 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
423 continue;
424 }
425 aliases[i] = ccv_nnc_tensor_symbol_alias_new(graph, outputs[0], ofs, stride, input_params, 0);
426 ofs[axis] += input_params.dim[axis];
427 }
428 // Format transform is more flexible.
429 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");
430 }
431}
432
433static ccv_cnnp_model_t* _ccv_cnnp_concat_copy(const ccv_cnnp_model_t* const self, void* const context);
434
435static const ccv_cnnp_model_vtab_t ccv_cnnp_concat_isa = {
436 .build = _ccv_cnnp_concat_build,
437 .copy = _ccv_cnnp_concat_copy,
438};
439
440ccv_cnnp_model_t* ccv_cnnp_concat(const int axis, const char* const name)
441{
442 ccv_cnnp_model_concat_t* const model_concat = (ccv_cnnp_model_concat_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_concat_t));
443 model_concat->super.isa = &ccv_cnnp_concat_isa;
444 model_concat->super.input_size = 0;
445 model_concat->super.outputs = &model_concat->output;
446 model_concat->super.output_size = 1;
447 model_concat->axis = axis;
448 ccv_cnnp_model_copy_name(&model_concat->super, name);
449 return (ccv_cnnp_model_t*)model_concat;
450}
451
452static ccv_cnnp_model_t* _ccv_cnnp_concat_copy(const ccv_cnnp_model_t* const super, void* const context)
453{
454 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
455 return ccv_cnnp_concat(self->axis, self->super.name);
456}
457
458typedef struct {
459 ccv_cnnp_model_t super;
460 int axis;
461 ccv_nnc_tensor_symbol_t outputs[1];
462} ccv_cnnp_model_chunk_t;
463
464static 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)
465{
466 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
467 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);
468 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"
, 468, __extension__ __PRETTY_FUNCTION__); }));
469 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
470 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
471 {
472 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);
473 int i;
474 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && input_params.dim[i] > 0; i++)
475 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);
476 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
477 }
478 ccv_nnc_tensor_param_t output_params = input_params;
479 int i;
480 const int nd = ccv_nnc_tensor_nd(output_params.dim);
481 const int axis = self->axis;
482 assert(axis < nd)((void) sizeof ((axis < nd) ? 1 : 0), __extension__ ({ if (
axis < nd) ; else __assert_fail ("axis < nd", "ccv_cnnp_model_addons.c"
, 482, __extension__ __PRETTY_FUNCTION__); }));
483 const int n = self->super.output_size;
484 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", 484, __extension__ __PRETTY_FUNCTION__
); }));
485 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"
, 485, __extension__ __PRETTY_FUNCTION__); }));
486 output_params.dim[axis] = output_params.dim[axis] / n;
487 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
488 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
489 ccv_nnc_tensor_get_stride(input_params.dim, stride);
490 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
491 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
492 {
493 for (i = 0; i < output_size; i++)
494 {
495 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
496 ofs[axis] += output_params.dim[axis];
497 }
498 } else {
499 // Otherwise, we need to check if it is permute. For permute, we cannot do alias directly.
500 // We need to first materialize the permute and then run reshape on top of it, otherwise it will be wrong.
501 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
502 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
503 // We identify permute by checking if the stride is not in descending order.
504 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
505 int i, no_permute = 1;
506 for (i = 1; no_permute && i < nd; i++)
507 if (old_stride[i - 1] < old_stride[i])
508 no_permute = 0;
509 if (no_permute)
510 { // Just straightforward reshape if there is no no permute.
511 for (i = 0; i < output_size; i++)
512 {
513 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, old_stride, output_params, 0);
514 ofs[axis] += output_params.dim[axis];
515 }
516 } else {
517 // Otherwise, we first do format transform to plain tensor and then do reshape.
518 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, input_params, 0);
519 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");
520 for (i = 0; i < output_size; i++)
521 {
522 outputs[i] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, ofs, stride, output_params, 0);
523 ofs[axis] += output_params.dim[axis];
524 }
525 }
526 }
527}
528
529static ccv_cnnp_model_t* _ccv_cnnp_chunk_copy(const ccv_cnnp_model_t* const self, void* const context);
530
531static const ccv_cnnp_model_vtab_t ccv_cnnp_chunk_isa = {
532 .build = _ccv_cnnp_chunk_build,
533 .copy = _ccv_cnnp_chunk_copy,
534};
535
536ccv_cnnp_model_t* ccv_cnnp_chunk(const int n, const int axis, const char* const name)
537{
538 assert(n >= 1)((void) sizeof ((n >= 1) ? 1 : 0), __extension__ ({ if (n >=
1) ; else __assert_fail ("n >= 1", "ccv_cnnp_model_addons.c"
, 538, __extension__ __PRETTY_FUNCTION__); }));
539 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));
540 model_chunk->super.isa = &ccv_cnnp_chunk_isa;
541 model_chunk->super.input_size = 1;
542 model_chunk->super.outputs = model_chunk->outputs;
543 model_chunk->super.output_size = n;
544 model_chunk->axis = axis;
545 ccv_cnnp_model_copy_name(&model_chunk->super, name);
546 return (ccv_cnnp_model_t*)model_chunk;
547}
548
549static ccv_cnnp_model_t* _ccv_cnnp_chunk_copy(const ccv_cnnp_model_t* const super, void* const context)
550{
551 const ccv_cnnp_model_chunk_t* const self = (const ccv_cnnp_model_chunk_t*)super;
552 return ccv_cnnp_chunk(self->super.output_size, self->axis, self->super.name);
553}
554
555typedef struct {
556 ccv_cnnp_model_t super;
557 ccv_nnc_tensor_symbol_t output;
558 int format;
559 int dim[CCV_NNC_MAX_DIM_ALLOC(12)];
560 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
561 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
562} ccv_cnnp_model_reshape_t;
563
564static 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)
565{
566 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"
, 566, __extension__ __PRETTY_FUNCTION__); }));
567 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", 567, __extension__ __PRETTY_FUNCTION__
); }));
568 ccv_cnnp_model_reshape_t* const self = (ccv_cnnp_model_reshape_t*)super;
569 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
570 {
571 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);
572 int i;
573 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && self->dim[i] > 0; i++)
574 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);
575 const int count = i;
576 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);
577 for (i = 1; i < count; i++)
578 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);
579 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);
580 for (i = 1; i < count; i++)
581 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);
582 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
583 }
584 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
585 if (params.dim[0] == 0)
586 {
587 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
588 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
589 if (ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], ofs, stride) < 0)
590 ccv_nnc_tensor_get_stride(params.dim, stride);
591 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, params, 0);
592 return;
593 }
594 int dim[CCV_NNC_MAX_DIM_ALLOC(12)];
595 memcpy(dim, self->dim, sizeof(dim));
596 int i, auto_idx = -1;
597 size_t known = 1;
598 const size_t tensor_count = ccv_nnc_tensor_count(params);
599 for (i = 0; i < CCV_NNC_MAX_DIM_ALLOC(12) && dim[i]; i++)
600 if (dim[i] == -1)
601 auto_idx = i;
602 else
603 known *= dim[i];
604 if (auto_idx >= 0)
605 {
606 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", 606, __extension__ __PRETTY_FUNCTION__
); }));
607 dim[auto_idx] = tensor_count / known;
608 }
609 if (CCV_CLI_OUTPUT_LEVEL_IS(CCV_CLI_VERBOSE)(CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
610 {
611 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);
612 int i;
613 for (i = 1; i < CCV_NNC_MAX_DIM_ALLOC(12) && params.dim[i] > 0; i++)
614 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);
615 PRINT(CCV_CLI_VERBOSE, ")\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf(")\n"); fflush(stdout); } } while (0);
616 }
617 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", 617, __extension__ __PRETTY_FUNCTION__
); }));
618 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
619 int stride_from_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
620 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
621 {
622 memcpy(params.dim, dim, sizeof(params.dim));
623 int* stride;
624 if (self->stride[0] == 0)
625 {
626 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
627 stride = stride_from_dim;
628 } else
629 stride = self->stride;
630 if (self->format > 0)
631 params.format = self->format;
632 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
633 } else {
634 // Otherwise, we need to check if it is permute. For permute, we cannot do alias directly.
635 // We need to first materialize the permute and then run reshape on top of it, otherwise it will be wrong.
636 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
637 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
638 // We identify permute by checking if the stride is not in descending order.
639 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
640 const int nd = ccv_nnc_tensor_nd(params.dim);
641 const int new_nd = ccv_nnc_tensor_nd(dim);
642 int i, no_permute = 1;
643 // If the new dim has different nd, or we actually have a stride, we need to check if it is no permute or not.
644 if (new_nd != nd || (self->stride[0] != 0 && memcmp(self->stride, old_stride, sizeof(self->stride))))
645 for (i = 1; no_permute && i < nd; i++)
646 if (old_stride[i - 1] < old_stride[i])
647 no_permute = 0;
648 if (no_permute)
649 { // Just straightforward reshape if there is no no permute.
650 memcpy(params.dim, dim, sizeof(params.dim));
651 int* stride;
652 if (self->stride[0] == 0)
653 {
654 if (new_nd != nd) // Cannot use old stride.
655 {
656 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
657 stride = stride_from_dim;
658 } else
659 stride = old_stride;
660 } else
661 stride = self->stride;
662 if (self->format > 0)
663 params.format = self->format;
664 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], self->ofs, stride, params, 0);
665 } else {
666 // Otherwise, we first do format transform to plain tensor and then do reshape.
667 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, params, 0);
668 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");
669 memcpy(params.dim, dim, sizeof(params.dim));
670 int* stride;
671 if (self->stride[0] == 0)
672 {
673 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
674 stride = stride_from_dim;
675 } else
676 stride = self->stride;
677 if (self->format > 0)
678 params.format = self->format;
679 // And then we create alias against the permuted one.
680 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, self->ofs, stride, params, 0);
681 }
682 }
683}
684
685static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context);
686
687static const ccv_cnnp_model_vtab_t ccv_cnnp_reshape_isa = {
688 .build = _ccv_cnnp_reshape_build,
689 .copy = _ccv_cnnp_reshape_copy,
690};
691
692ccv_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)
693{
694 ccv_cnnp_model_reshape_t* const model_reshape = (ccv_cnnp_model_reshape_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reshape_t));
695 model_reshape->super.isa = &ccv_cnnp_reshape_isa;
696 model_reshape->super.input_size = 1;
697 model_reshape->super.outputs = &model_reshape->output;
698 model_reshape->super.output_size = 1;
699 ccv_cnnp_model_copy_name(&model_reshape->super, name);
700 model_reshape->format = format;
701 memcpy(model_reshape->dim, dim, sizeof(model_reshape->dim));
702 memcpy(model_reshape->ofs, ofs, sizeof(model_reshape->ofs));
703 if (stride[0] != 0)
704 memcpy(model_reshape->stride, stride, sizeof(model_reshape->stride));
705 return (ccv_cnnp_model_t*)model_reshape;
706}
707
708static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context)
709{
710 const ccv_cnnp_model_reshape_t* const self = (const ccv_cnnp_model_reshape_t*)super;
711 return ccv_cnnp_reshape(self->format, self->dim, self->ofs, self->stride, self->super.name);
712}
713
714typedef struct {
715 ccv_cnnp_model_t super;
716 ccv_nnc_tensor_symbol_t output;
717 int type;
718 int begin[CCV_NNC_MAX_DIM_ALLOC(12)];
719 int end[CCV_NNC_MAX_DIM_ALLOC(12)];
720} ccv_cnnp_model_pad_t;
721
722static 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)
723{
724 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"
, 724, __extension__ __PRETTY_FUNCTION__); }));
725 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", 725, __extension__ __PRETTY_FUNCTION__
); }));
726 ccv_cnnp_model_pad_t* const self = (ccv_cnnp_model_pad_t*)super;
727 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);
728 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
729 const int nd = ccv_nnc_tensor_nd(input_params.dim);
730 ccv_nnc_tensor_param_t params = input_params;
731 int i;
732 for (i = 0 ; i < nd; i++)
733 params.dim[i] += self->begin[i] + self->end[i];
734 const ccv_nnc_tensor_symbol_t padded = ccv_nnc_tensor_symbol_new(graph, params, 0);
735 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);
736 memcpy(pad.info.size.dim, self->begin, sizeof(pad.info.size.dim));
737 memcpy(pad.info.pad.end, self->end, sizeof(pad.info.pad.end));
738 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");
739 outputs[0] = padded;
740}
741
742static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context);
743
744static const ccv_cnnp_model_vtab_t ccv_cnnp_pad_isa = {
745 .build = _ccv_cnnp_pad_build,
746 .copy = _ccv_cnnp_pad_copy,
747};
748
749ccv_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)
750{
751 ccv_cnnp_model_pad_t* const model_pad = (ccv_cnnp_model_pad_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pad_t));
752 model_pad->super.isa = &ccv_cnnp_pad_isa;
753 model_pad->super.input_size = 1;
754 model_pad->super.outputs = &model_pad->output;
755 model_pad->super.output_size = 1;
756 ccv_cnnp_model_copy_name(&model_pad->super, name);
757 model_pad->type = type;
758 memcpy(model_pad->begin, begin, sizeof(model_pad->begin));
759 memcpy(model_pad->end, end, sizeof(model_pad->end));
760 return (ccv_cnnp_model_t*)model_pad;
761}
762
763static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context)
764{
765 const ccv_cnnp_model_pad_t* const self = (const ccv_cnnp_model_pad_t*)super;
766 return ccv_cnnp_pad(self->type, self->begin, self->end, self->super.name);
767}
768
769typedef struct {
770 ccv_cnnp_model_t super;
771 ccv_nnc_tensor_symbol_t output;
772} ccv_cnnp_model_identity_t;
773
774static 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)
775{
776 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"
, 776, __extension__ __PRETTY_FUNCTION__); }));
777 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", 777, __extension__ __PRETTY_FUNCTION__
); }));
778 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);
779 outputs[0] = inputs[0];
780}
781
782static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context);
783
784static const ccv_cnnp_model_vtab_t ccv_cnnp_identity_isa = {
785 .build = _ccv_cnnp_identity_build,
786 .copy = _ccv_cnnp_identity_copy,
787};
788
789ccv_cnnp_model_t* ccv_cnnp_identity(const char* const name)
790{
791 ccv_cnnp_model_identity_t* const model_identity = (ccv_cnnp_model_identity_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_identity_t));
792 model_identity->super.isa = &ccv_cnnp_identity_isa;
793 model_identity->super.input_size = 1;
794 model_identity->super.outputs = &model_identity->output;
795 model_identity->super.output_size = 1;
796 ccv_cnnp_model_copy_name(&model_identity->super, name);
797 return (ccv_cnnp_model_t*)model_identity;
798}
799
800static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context)
801{
802 const ccv_cnnp_model_identity_t* const self = (const ccv_cnnp_model_identity_t*)super;
803 return ccv_cnnp_identity(self->super.name);
804}
805
806typedef struct {
807 ccv_cnnp_model_t super;
808 ccv_nnc_tensor_symbol_t output;
809 int index[CCV_NNC_MAX_DIM_ALLOC(12)];
810} ccv_cnnp_model_permute_t;
811
812static 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)
813{
814 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"
, 814, __extension__ __PRETTY_FUNCTION__); }));
815 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", 815, __extension__ __PRETTY_FUNCTION__
); }));
816 ccv_cnnp_model_permute_t* const self = (ccv_cnnp_model_permute_t*)super;
817 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);
818 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
819 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
820 const int nd = ccv_nnc_tensor_nd(params.dim);
821 int input_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
822 memcpy(input_dim, params.dim, sizeof(params.dim));
823 int input_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
824 int output_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
825 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If it is not an alias. Find stride and permute.
826 {
827 ccv_nnc_tensor_get_stride(input_dim, input_stride);
828 int i;
829 for (i = 0; i < nd; i++)
830 {
831 const int idx = self->index[i];
832 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"
, 832, __extension__ __PRETTY_FUNCTION__); }));
833 params.dim[i] = input_dim[idx];
834 output_stride[i] = input_stride[idx];
835 }
836 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ccv_nnc_no_ofs, output_stride, params, 0);
837 } else {
838 // if it is an alias, we can get the stride from it and use that.
839 int input_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
840 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], input_ofs, input_stride);
841 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", 841, __extension__ __PRETTY_FUNCTION__
); }));
842 int output_ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
843 int i;
844 for (i = 0; i < nd; i++)
845 {
846 const int idx = self->index[i];
847 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"
, 847, __extension__ __PRETTY_FUNCTION__); }));
848 params.dim[i] = input_dim[idx];
849 output_stride[i] = input_stride[idx];
850 output_ofs[i] = input_ofs[idx];
851 }
852 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], output_ofs, output_stride, params, 0);
853 }
854}
855
856static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context);
857
858static const ccv_cnnp_model_vtab_t ccv_cnnp_permute_isa = {
859 .build = _ccv_cnnp_permute_build,
860 .copy = _ccv_cnnp_permute_copy,
861};
862
863ccv_cnnp_model_t* ccv_cnnp_permute(const int index[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
864{
865 ccv_cnnp_model_permute_t* const model_permute = (ccv_cnnp_model_permute_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_permute_t));
866 model_permute->super.isa = &ccv_cnnp_permute_isa;
867 model_permute->super.input_size = 1;
868 model_permute->super.outputs = &model_permute->output;
869 model_permute->super.output_size = 1;
870 ccv_cnnp_model_copy_name(&model_permute->super, name);
871 memcpy(model_permute->index, index, sizeof(model_permute->index));
872 return (ccv_cnnp_model_t*)model_permute;
873}
874
875static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context)
876{
877 const ccv_cnnp_model_permute_t* const self = (const ccv_cnnp_model_permute_t*)super;
878 return ccv_cnnp_permute(self->index, self->super.name);
879}
880
881typedef struct {
882 ccv_cnnp_model_t super;
883 int index;
884 ccv_nnc_tensor_symbol_t output;
885} ccv_cnnp_model_extract_t;
886
887static 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)
888{
889 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", 889, __extension__ __PRETTY_FUNCTION__
); }));
890 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
891 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);
892 outputs[0] = inputs[self->index];
893}
894
895static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const self, void* const context);
896
897static const ccv_cnnp_model_vtab_t ccv_cnnp_extract_isa = {
898 .build = _ccv_cnnp_extract_build,
899 .copy = _ccv_cnnp_extract_copy,
900};
901
902ccv_cnnp_model_t* ccv_cnnp_extract(const int index, const char* const name)
903{
904 ccv_cnnp_model_extract_t* const model_extract = (ccv_cnnp_model_extract_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_extract_t));
905 model_extract->index = index;
906 model_extract->super.isa = &ccv_cnnp_extract_isa;
907 model_extract->super.input_size = 0;
908 model_extract->super.outputs = &model_extract->output;
909 model_extract->super.output_size = 1;
910 ccv_cnnp_model_copy_name(&model_extract->super, name);
911 return (ccv_cnnp_model_t*)model_extract;
912}
913
914static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const super, void* const context)
915{
916 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
917 return ccv_cnnp_extract(self->index, self->super.name);
918}
919
920typedef struct {
921 ccv_cnnp_model_t super;
922 ccv_nnc_tensor_symbol_t output;
923} ccv_cnnp_model_flatten_t;
924
925static 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)
926{
927 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);
928 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"
, 928, __extension__ __PRETTY_FUNCTION__); }));
929 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", 929, __extension__ __PRETTY_FUNCTION__
); }));
930 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
931 ccv_nnc_tensor_param_t output_params = params;
932 memset(output_params.dim, 0, sizeof(output_params.dim));
933 output_params.dim[0] = ccv_nnc_tensor_get_n(params);
934 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", 934, __extension__ __PRETTY_FUNCTION__
); }));
935 output_params.dim[1] = ccv_nnc_tensor_count(params) / output_params.dim[0];
936 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
937 ccv_nnc_tensor_get_stride(output_params.dim, stride);
938 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], DIM_ALLOC()(int [(12)]){}, stride, output_params, 0);
939}
940
941static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context);
942
943static const ccv_cnnp_model_vtab_t ccv_cnnp_flatten_isa = {
944 .build = _ccv_cnnp_flatten_build,
945 .copy = _ccv_cnnp_flatten_copy,
946};
947
948ccv_cnnp_model_t* ccv_cnnp_flatten(const char* const name)
949{
950 ccv_cnnp_model_flatten_t* const model_flatten = (ccv_cnnp_model_flatten_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_flatten_t));
951 model_flatten->super.isa = &ccv_cnnp_flatten_isa;
952 model_flatten->super.input_size = 1;
953 model_flatten->super.outputs = &model_flatten->output;
954 model_flatten->super.output_size = 1;
955 ccv_cnnp_model_copy_name(&model_flatten->super, name);
956 return (ccv_cnnp_model_t*)model_flatten;
957}
958
959static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context)
960{
961 return ccv_cnnp_flatten(self->name);
962}
963
964// MARK - Batch Norm Layer
965
966typedef struct {
967 ccv_cnnp_model_t super;
968 ccv_nnc_tensor_symbol_t output;
969 ccv_nnc_tensor_symbol_t bias;
970 ccv_nnc_tensor_symbol_t scale;
971 ccv_nnc_graph_exec_symbol_t batch_norm;
972 ccv_nnc_cmd_param_t params;
973 ccv_array_t* zero_inits;
974 ccv_array_t* retainables;
975} ccv_cnnp_model_batch_norm_t;
976
977static 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)
978{
979 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"
, 979, __extension__ __PRETTY_FUNCTION__); }));
980 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", 980, __extension__ __PRETTY_FUNCTION__
); }));
981 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
982 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);
983 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
984 const int nd = ccv_nnc_tensor_nd(params.dim);
985 ccv_nnc_tensor_param_t bias_params = params;
986 memset(bias_params.dim, 0, sizeof(bias_params.dim));
987 // If the accuracy is not enough, bump it to 32-bit floating point.
988 if (bias_params.datatype != CCV_32F && bias_params.datatype != CCV_64F)
989 bias_params.datatype = CCV_32F;
990 bias_params.dim[0] = nd > 1 ? ccv_nnc_tensor_get_c(params) : params.dim[0];
991 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, params, 0);
992 // Both scale and bias are shared between if this model is reused.
993 if (!self->scale.graph)
994 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
995 if (!self->bias.graph)
996 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
997 const ccv_nnc_tensor_symbol_t scale = ccv_cnnp_model_get_symbol(super, self->scale);
998 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
999 const ccv_nnc_tensor_symbol_t mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "mean");
1000 const ccv_nnc_tensor_symbol_t var = ccv_nnc_tensor_symbol_new(graph, bias_params, "var");
1001 // Otherwise, notice mean, var, saved_mean, saved_inv_std are not reused.
1002 if (!self->zero_inits)
1003 self->zero_inits = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
1004 ccv_array_push(self->zero_inits, &mean);
1005 ccv_array_push(self->zero_inits, &var);
1006 const ccv_nnc_tensor_symbol_t out_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_mean");
1007 const ccv_nnc_tensor_symbol_t out_var = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_var");
1008 if (!self->retainables)
1009 self->retainables = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
1010 ccv_array_push(self->retainables, &out_mean);
1011 ccv_array_push(self->retainables, &out_var);
1012 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_mean");
1013 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_inv_std");
1014 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1015 ccv_nnc_cmd_param_t batch_norm = self->params;
1016 batch_norm.bnorm.count = hw >= 0 ? CCV_NNC_MAX_DIM(2) + 1 : 1;
1017 int i;
1018 batch_norm.bnorm.axis[0] = (params.format == CCV_TENSOR_FORMAT_CHWN) ? 3 : 0;
1019 if (hw >= 0)
1020 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1021 batch_norm.bnorm.axis[i + 1] = i + hw;
1022 self->params = batch_norm;
1023 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], scale, bias, mean, var)(const ccv_nnc_tensor_symbol_t []){inputs[0], scale, 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");
1024 outputs[0] = output;
1025}
1026
1027static 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)
1028{
1029 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1030 if (self->scale.graph)
1031 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);
1032 if (self->bias.graph)
1033 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);
1034 int i;
1035 if (self->zero_inits)
1036 for (i = 0; i < self->zero_inits->rnum; i++)
1037 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))));
1038}
1039
1040static 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)
1041{
1042 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1043 if (self->scale.graph)
1044 add_to_array(parameters, self->scale, is_trainable);
1045 if (self->bias.graph)
1046 add_to_array(parameters, self->bias, is_trainable);
1047}
1048
1049static 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)
1050{
1051 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1052 int i;
1053 if (self->retainables)
1054 for (i = 0; i < self->retainables->rnum; i++)
1055 {
1056 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)));
1057 add_to_array(outputs, symbol, 0);
1058 }
1059}
1060
1061static 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)
1062{
1063 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1064 if (self->batch_norm.graph)
1065 {
1066 self->params.bnorm.is_test = is_test;
1067 updater(context, self->batch_norm, ccv_nnc_cmd(CCV_NNC_BATCH_NORM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
1068 }
1069}
1070
1071static void _ccv_cnnp_batch_norm_deinit(ccv_cnnp_model_t* const super)
1072{
1073 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1074 if (self->zero_inits)
1075 ccv_array_free(self->zero_inits);
1076 if (self->retainables)
1077 ccv_array_free(self->retainables);
1078}
1079
1080static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
1081
1082static const ccv_cnnp_model_vtab_t ccv_cnnp_batch_norm_isa = {
1083 .build = _ccv_cnnp_batch_norm_build,
1084 .init_states = _ccv_cnnp_batch_norm_init_states,
1085 .add_to_parameter = _ccv_cnnp_batch_norm_add_to_parameter,
1086 .add_to_output = _ccv_cnnp_batch_norm_add_to_output,
1087 .copy = _ccv_cnnp_batch_norm_copy,
1088 .set_is_test = _ccv_cnnp_batch_norm_set_is_test,
1089 .deinit = _ccv_cnnp_batch_norm_deinit,
1090};
1091
1092ccv_cnnp_model_t* ccv_cnnp_batch_norm(const float momentum, const float epsilon, const int is_trainable, const char* const name)
1093{
1094 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));
1095 model_batch_norm->super.isa = &ccv_cnnp_batch_norm_isa;
1096 model_batch_norm->super.input_size = 1;
1097 model_batch_norm->super.outputs = &model_batch_norm->output;
1098 model_batch_norm->super.output_size = 1;
1099 model_batch_norm->super.is_trainable = is_trainable;
1100 ccv_cnnp_model_copy_name(&model_batch_norm->super, name);
1101 model_batch_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
1102 model_batch_norm->scale.graph = 0;
1103 model_batch_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1104 model_batch_norm->bias.graph = 0;
1105 model_batch_norm->params.bnorm.momentum = momentum;
1106 model_batch_norm->params.bnorm.epsilon = epsilon;
1107 return (ccv_cnnp_model_t*)model_batch_norm;
1108}
1109
1110static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
1111{
1112 const ccv_cnnp_model_batch_norm_t* const self = (const ccv_cnnp_model_batch_norm_t*)super;
1113 return ccv_cnnp_batch_norm(self->params.bnorm.momentum, self->params.bnorm.epsilon, self->super.is_trainable, self->super.name);
1114}
1115
1116// MARK - Convolution Layer
1117
1118typedef struct {
1119 ccv_cnnp_model_t super;
1120 ccv_nnc_tensor_symbol_t output;
1121 ccv_nnc_tensor_symbol_t weights;
1122 ccv_nnc_tensor_symbol_t bias;
1123 int groups;
1124 int filters;
1125 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1126 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1127 int no_bias;
1128 int format;
1129 ccv_nnc_hint_t hint;
1130} ccv_cnnp_model_convolution_t;
1131
1132static 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)
1133{
1134 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1135 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);
1136 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"
, 1136, __extension__ __PRETTY_FUNCTION__); }));
1137 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", 1137, __extension__ __PRETTY_FUNCTION__
); }));
1138 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1139 int i;
1140 const int k_nd = ccv_nnc_tensor_nd(self->kdim);
1141 const int nd = k_nd + 2;
1142 ccv_nnc_tensor_param_t weights_params = params;
1143 if (self->format)
1144 weights_params.format = self->format;
1145 ccv_nnc_tensor_set_n(&weights_params, self->filters);
1146 const int a_nd = ccv_nnc_tensor_nd(params.dim);
1147 int c;
1148 switch (params.format)
1149 {
1150 case CCV_TENSOR_FORMAT_NHWC:
1151 c = params.dim[a_nd - 1];
1152 break;
1153 case CCV_TENSOR_FORMAT_NCHW:
1154 if (a_nd == k_nd + 1)
1155 c = params.dim[0];
1156 else
1157 c = params.dim[a_nd <= 1 ? 0 : 1];
1158 break;
1159 case CCV_TENSOR_FORMAT_CHWN:
1160 c = params.dim[0];
1161 break;
1162 }
1163 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", 1163, __extension__ __PRETTY_FUNCTION__
); }));
1164 ccv_nnc_tensor_set_c(&weights_params, nd, c / self->groups);
1165 int hw = -1;
1166 if (weights_params.format == CCV_TENSOR_FORMAT_NHWC || weights_params.format == CCV_TENSOR_FORMAT_CHWN)
1167 hw = 1;
1168 else if (weights_params.format == CCV_TENSOR_FORMAT_NCHW)
1169 hw = 2;
1170 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1170, __extension__ __PRETTY_FUNCTION__); }));
1171 for (i = 0; i < k_nd; i++)
1172 weights_params.dim[i + hw] = self->kdim[i];
1173 if (!self->weights.graph)
1174 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1175 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"
, 1175, __extension__ __PRETTY_FUNCTION__); }));
1176 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1177 ccv_nnc_tensor_param_t bias_params = params;
1178 if (self->format)
1179 bias_params.format = self->format;
1180 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1181 bias_params.dim[0] = self->filters;
1182 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);
1183 for (i = 0; i < k_nd; i++)
1184 cmd.info.size.dim[i] = self->kdim[i];
1185 cmd.info.size.dim[k_nd] = c;
1186 memcpy(cmd.info.convolution.dilation, self->dilation, sizeof(self->dilation));
1187 ccv_nnc_tensor_param_t output_params;
1188 // Dilate weight size based on the dilation factor.
1189 for (i = 0; i < k_nd; i++)
1190 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;
1191 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1192 params,
1193 weights_params,
1194 bias_params,
1195 }, 3, self->hint, &output_params, 1);
1196 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1197 ccv_nnc_graph_exec_symbol_t convolution;
1198 if (self->no_bias)
1199 convolution = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], 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");
1200 else {
1201 if (!self->bias.graph)
1202 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1203 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1204 convolution = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], weights, 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");
1205 }
1206 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution, self->hint);
1207 outputs[0] = output;
1208}
1209
1210static 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)
1211{
1212 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1213 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1214 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
; });
1215 const int count = ccv_nnc_tensor_count(weight_params);
1216 const float std = sqrtf(2) / sqrtf(count / n);
1217 const float bound = sqrtf(3) * std;
1218 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);
1219 if (self->bias.graph)
1220 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);
1221}
1222
1223static 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)
1224{
1225 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1226 add_to_array(parameters, self->weights, is_trainable);
1227 if (self->bias.graph)
1228 add_to_array(parameters, self->bias, is_trainable);
1229}
1230
1231static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context);
1232
1233static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_isa = {
1234 .build = _ccv_cnnp_convolution_build,
1235 .init_states = _ccv_cnnp_convolution_init_states,
1236 .add_to_parameter = _ccv_cnnp_convolution_add_to_parameter,
1237 .copy = _ccv_cnnp_convolution_copy,
1238};
1239
1240ccv_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)
1241{
1242 ccv_cnnp_model_convolution_t* const model_convolution = (ccv_cnnp_model_convolution_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_convolution_t));
1243 model_convolution->super.isa = &ccv_cnnp_convolution_isa;
1244 model_convolution->super.input_size = 1;
1245 model_convolution->super.outputs = &model_convolution->output;
1246 model_convolution->super.output_size = 1;
1247 model_convolution->super.is_trainable = is_trainable;
1248 ccv_cnnp_model_copy_name(&model_convolution->super, name);
1249 model_convolution->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1250 model_convolution->weights.graph = 0;
1251 model_convolution->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1252 model_convolution->bias.graph = 0;
1253 model_convolution->groups = groups;
1254 model_convolution->filters = filters;
1255 memcpy(model_convolution->kdim, kdim, sizeof(model_convolution->kdim));
1256 memcpy(model_convolution->dilation, dilation, sizeof(model_convolution->dilation));
1257 model_convolution->no_bias = no_bias;
1258 model_convolution->hint = hint;
1259 model_convolution->format = format;
1260 return (ccv_cnnp_model_t*)model_convolution;
1261}
1262
1263static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context)
1264{
1265 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1266 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);
1267}
1268
1269// MARK - Convolution Transpose Layer
1270
1271typedef struct {
1272 ccv_cnnp_model_t super;
1273 ccv_nnc_tensor_symbol_t output;
1274 ccv_nnc_tensor_symbol_t weights;
1275 ccv_nnc_tensor_symbol_t bias;
1276 int groups;
1277 int filters;
1278 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1279 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1280 int output_padding;
1281 int no_bias;
1282 int format;
1283 ccv_nnc_hint_t hint;
1284} ccv_cnnp_model_convolution_transpose_t;
1285
1286static 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)
1287{
1288 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1289 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);
1290 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"
, 1290, __extension__ __PRETTY_FUNCTION__); }));
1291 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", 1291, __extension__ __PRETTY_FUNCTION__
); }));
1292 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1293 int i;
1294 const int nd = CCV_NNC_MAX_DIM(2) + 2;
1295 ccv_nnc_tensor_param_t weights_params = params;
1296 if (self->format)
1297 weights_params.format = self->format;
1298 const int c = ccv_nnc_tensor_get_c(params);
1299 ccv_nnc_tensor_set_n(&weights_params, c);
1300 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", 1300, __extension__ __PRETTY_FUNCTION__
); }));
1301 ccv_nnc_tensor_set_c(&weights_params, nd, self->filters / self->groups);
1302 const int hw = ccv_nnc_tensor_hw(weights_params, nd, CCV_NNC_MAX_DIM(2));
1303 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1303, __extension__ __PRETTY_FUNCTION__); }));
1304 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1305 weights_params.dim[i + hw] = self->kdim[i];
1306 if (!self->weights.graph)
1307 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1308 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"
, 1308, __extension__ __PRETTY_FUNCTION__); }));
1309 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1310 ccv_nnc_tensor_param_t bias_params = params;
1311 if (self->format)
1312 bias_params.format = self->format;
1313 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1314 bias_params.dim[0] = self->filters;
1315 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);
1316 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1317 cmd.info.size.dim[i] = self->kdim[i];
1318 cmd.info.size.dim[CCV_NNC_MAX_DIM(2)] = c;
1319 memcpy(cmd.info.convolution_transpose.dilation, self->dilation, sizeof(self->dilation));
1320 ccv_nnc_tensor_param_t output_params;
1321 // Dilate weight size based on the dilation factor.
1322 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1323 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;
1324 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1325 params,
1326 weights_params,
1327 bias_params,
1328 }, 3, self->hint, &output_params, 1);
1329 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1330 ccv_nnc_graph_exec_symbol_t convolution_transpose;
1331 if (self->no_bias)
1332 convolution_transpose = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], 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");
1333 else {
1334 if (!self->bias.graph)
1335 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1336 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1337 convolution_transpose = ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], weights, 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");
1338 }
1339 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution_transpose, self->hint);
1340 outputs[0] = output;
1341}
1342
1343static 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)
1344{
1345 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1346 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1347 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
; });
1348 const int count = ccv_nnc_tensor_count(weight_params);
1349 const float std = sqrtf(2) / sqrtf(count / n);
1350 const float bound = sqrtf(3) * std;
1351 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);
1352 if (self->bias.graph)
1353 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);
1354}
1355
1356static 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)
1357{
1358 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1359 add_to_array(parameters, self->weights, is_trainable);
1360 if (self->bias.graph)
1361 add_to_array(parameters, self->bias, is_trainable);
1362}
1363
1364static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
1365
1366static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_transpose_isa = {
1367 .build = _ccv_cnnp_convolution_transpose_build,
1368 .init_states = _ccv_cnnp_convolution_transpose_init_states,
1369 .add_to_parameter = _ccv_cnnp_convolution_transpose_add_to_parameter,
1370 .copy = _ccv_cnnp_convolution_transpose_copy,
1371};
1372
1373ccv_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)
1374{
1375 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));
1376 model_convolution_transpose->super.isa = &ccv_cnnp_convolution_transpose_isa;
1377 model_convolution_transpose->super.input_size = 1;
1378 model_convolution_transpose->super.outputs = &model_convolution_transpose->output;
1379 model_convolution_transpose->super.output_size = 1;
1380 model_convolution_transpose->super.is_trainable = is_trainable;
1381 ccv_cnnp_model_copy_name(&model_convolution_transpose->super, name);
1382 model_convolution_transpose->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1383 model_convolution_transpose->weights.graph = 0;
1384 model_convolution_transpose->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1385 model_convolution_transpose->bias.graph = 0;
1386 model_convolution_transpose->groups = groups;
1387 model_convolution_transpose->filters = filters;
1388 memcpy(model_convolution_transpose->kdim, kdim, sizeof(model_convolution_transpose->kdim));
1389 memcpy(model_convolution_transpose->dilation, dilation, sizeof(model_convolution_transpose->dilation));
1390 model_convolution_transpose->output_padding = output_padding;
1391 model_convolution_transpose->no_bias = no_bias;
1392 model_convolution_transpose->hint = hint;
1393 model_convolution_transpose->format = format;
1394 return (ccv_cnnp_model_t*)model_convolution_transpose;
1395}
1396
1397static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
1398{
1399 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1400 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);
1401}
1402
1403// MARK - Dense Layer
1404
1405typedef struct {
1406 ccv_cnnp_model_t super;
1407 ccv_nnc_tensor_symbol_t output;
1408 ccv_nnc_tensor_symbol_t weights;
1409 ccv_nnc_tensor_symbol_t bias;
1410 int count;
1411 int no_bias;
1412 int flags;
1413} ccv_cnnp_model_dense_t;
1414
1415static 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)
1416{
1417 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1418 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);
1419 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"
, 1419, __extension__ __PRETTY_FUNCTION__); }));
1420 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", 1420, __extension__ __PRETTY_FUNCTION__
); }));
1421 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1422 ccv_nnc_tensor_param_t weights_params = params;
1423 memset(weights_params.dim, 0, sizeof(weights_params.dim));
1424 if (params.dim[0] != 0)
1425 {
1426 weights_params.dim[0] = self->count;
1427 weights_params.dim[1] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
1428 }
1429 if (!self->weights.graph)
1430 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1431 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"
, 1431, __extension__ __PRETTY_FUNCTION__); }));
1432 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1433 ccv_nnc_tensor_param_t bias_params = params;
1434 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1435 bias_params.dim[0] = self->count;
1436 ccv_nnc_cmd_t cmd = {0};
1437 cmd.cmd = CCV_NNC_GEMM_FORWARD;
1438 cmd.info.blas.a[0] = 1;
1439 cmd.info.blas.a[1] = 1;
1440 cmd.info.blas.transpose_b[0] = 0;
1441 cmd.info.blas.transpose_b[1] = 1;
1442 cmd.info.blas.flags = self->flags;
1443 ccv_nnc_tensor_param_t output_params;
1444 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1445 params,
1446 weights_params,
1447 bias_params,
1448 }, 3, ccv_nnc_no_hint, &output_params, 1);
1449 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1450 if (self->no_bias)
1451 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], 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");
1452 else {
1453 if (!self->bias.graph)
1454 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1455 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1456 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], weights, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], weights, 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");
1457 }
1458 outputs[0] = output;
1459}
1460
1461static 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)
1462{
1463 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1464 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1465 const int c = weight_params.dim[1];
1466 const float std = sqrtf(2) / sqrtf(c);
1467 const float bound = sqrtf(3) * std;
1468 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);
1469 if (self->bias.graph)
1470 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);
1471}
1472
1473static 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)
1474{
1475 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1476 add_to_array(parameters, self->weights, is_trainable);
1477 if (self->bias.graph)
1478 add_to_array(parameters, self->bias, is_trainable);
1479}
1480
1481static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
1482
1483static const ccv_cnnp_model_vtab_t ccv_cnnp_dense_isa = {
1484 .build = _ccv_cnnp_dense_build,
1485 .init_states = _ccv_cnnp_dense_init_states,
1486 .add_to_parameter = _ccv_cnnp_dense_add_to_parameter,
1487 .copy = _ccv_cnnp_dense_copy,
1488};
1489
1490ccv_cnnp_model_t* ccv_cnnp_dense(const int count, const int no_bias, const int flags, const int is_trainable, const char* const name)
1491{
1492 ccv_cnnp_model_dense_t* const model_dense = (ccv_cnnp_model_dense_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dense_t));
1493 model_dense->super.isa = &ccv_cnnp_dense_isa;
1494 model_dense->super.input_size = 1;
1495 model_dense->super.outputs = &model_dense->output;
1496 model_dense->super.output_size = 1;
1497 model_dense->super.is_trainable = is_trainable;
1498 ccv_cnnp_model_copy_name(&model_dense->super, name);
1499 model_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1500 model_dense->weights.graph = 0;
1501 model_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1502 model_dense->bias.graph = 0;
1503 model_dense->count = count;
1504 model_dense->no_bias = no_bias;
1505 model_dense->flags = flags;
1506 return (ccv_cnnp_model_t*)model_dense;
1507}
1508
1509static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
1510{
1511 const ccv_cnnp_model_dense_t* const self = (const ccv_cnnp_model_dense_t*)super;
1512 return ccv_cnnp_dense(self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
1513}
1514
1515// MARK - Pool Layers
1516
1517typedef struct {
1518 ccv_cnnp_model_t super;
1519 ccv_nnc_tensor_symbol_t output;
1520 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1521 ccv_nnc_hint_t hint;
1522} ccv_cnnp_model_pool_t;
1523
1524static 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)
1525{
1526 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1527 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);
1528 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"
, 1528, __extension__ __PRETTY_FUNCTION__); }));
1529 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", 1529, __extension__ __PRETTY_FUNCTION__
); }));
1530 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1531 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1532 ccv_nnc_cmd_t cmd;
1533 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1534 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);
1535 else
1536 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);
1537 ccv_nnc_tensor_param_t output_params;
1538 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1539 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1540 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");
1541 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1542 outputs[0] = pool_output;
1543}
1544
1545static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1546
1547static const ccv_cnnp_model_vtab_t ccv_cnnp_max_pool_isa = {
1548 .build = _ccv_cnnp_max_pool_build,
1549 .copy = _ccv_cnnp_max_pool_copy,
1550};
1551
1552ccv_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)
1553{
1554 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1555 model_pool->super.isa = &ccv_cnnp_max_pool_isa;
1556 model_pool->super.input_size = 1;
1557 model_pool->super.outputs = &model_pool->output;
1558 model_pool->super.output_size = 1;
1559 ccv_cnnp_model_copy_name(&model_pool->super, name);
1560 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1561 model_pool->hint = hint;
1562 return (ccv_cnnp_model_t*)model_pool;
1563}
1564
1565static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1566{
1567 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1568 return ccv_cnnp_max_pool(self->kdim, self->hint, self->super.name);
1569}
1570
1571static 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)
1572{
1573 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1574 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);
1575 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"
, 1575, __extension__ __PRETTY_FUNCTION__); }));
1576 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", 1576, __extension__ __PRETTY_FUNCTION__
); }));
1577 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1578 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1579 ccv_nnc_cmd_t cmd;
1580 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1581 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);
1582 else
1583 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);
1584 ccv_nnc_tensor_param_t output_params;
1585 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1586 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1587 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");
1588 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1589 outputs[0] = pool_output;
1590}
1591
1592static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1593
1594static const ccv_cnnp_model_vtab_t ccv_cnnp_average_pool_isa = {
1595 .build = _ccv_cnnp_average_pool_build,
1596 .copy = _ccv_cnnp_average_pool_copy,
1597};
1598
1599ccv_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)
1600{
1601 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1602 model_pool->super.isa = &ccv_cnnp_average_pool_isa;
1603 model_pool->super.input_size = 1;
1604 model_pool->super.outputs = &model_pool->output;
1605 model_pool->super.output_size = 1;
1606 ccv_cnnp_model_copy_name(&model_pool->super, name);
1607 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1608 model_pool->hint = hint;
1609 return (ccv_cnnp_model_t*)model_pool;
1610}
1611
1612static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1613{
1614 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1615 return ccv_cnnp_average_pool(self->kdim, self->hint, self->super.name);
1616}
1617
1618// MARK - RELU Layer
1619
1620typedef struct {
1621 ccv_cnnp_model_t super;
1622 ccv_nnc_tensor_symbol_t output;
1623} ccv_cnnp_model_relu_t;
1624
1625static 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)
1626{
1627 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);
1628 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"
, 1628, __extension__ __PRETTY_FUNCTION__); }));
1629 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", 1629, __extension__ __PRETTY_FUNCTION__
); }));
1630 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1631 ccv_nnc_tensor_param_t output_params;
1632 const ccv_nnc_cmd_t relu = CMD_RELU_FORWARD()ccv_nnc_cmd(CCV_NNC_RELU_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1633 ccv_nnc_hint_tensor_auto(relu, (ccv_nnc_tensor_param_t []){
1634 params,
1635 }, 1, ccv_nnc_no_hint, &output_params, 1);
1636 const ccv_nnc_tensor_symbol_t relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1637 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");
1638 outputs[0] = relu_output;
1639}
1640
1641static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1642
1643static const ccv_cnnp_model_vtab_t ccv_cnnp_relu_isa = {
1644 .build = _ccv_cnnp_relu_build,
1645 .copy = _ccv_cnnp_relu_copy,
1646};
1647
1648ccv_cnnp_model_t* ccv_cnnp_relu(const char* const name)
1649{
1650 ccv_cnnp_model_relu_t* const model_relu = (ccv_cnnp_model_relu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_relu_t));
1651 model_relu->super.isa = &ccv_cnnp_relu_isa;
1652 model_relu->super.input_size = 1;
1653 model_relu->super.outputs = &model_relu->output;
1654 model_relu->super.output_size = 1;
1655 ccv_cnnp_model_copy_name(&model_relu->super, name);
1656 return (ccv_cnnp_model_t*)model_relu;
1657}
1658
1659static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context)
1660{
1661 return ccv_cnnp_relu(self->name);
1662}
1663
1664// MARK - Sigmoid Layer
1665
1666typedef struct {
1667 ccv_cnnp_model_t super;
1668 ccv_nnc_tensor_symbol_t output;
1669} ccv_cnnp_model_sigmoid_t;
1670
1671static 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)
1672{
1673 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);
1674 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"
, 1674, __extension__ __PRETTY_FUNCTION__); }));
1675 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", 1675, __extension__ __PRETTY_FUNCTION__
); }));
1676 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1677 ccv_nnc_tensor_param_t output_params;
1678 const ccv_nnc_cmd_t sigmoid = CMD_SIGMOID_FORWARD()ccv_nnc_cmd(CCV_NNC_SIGMOID_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1679 ccv_nnc_hint_tensor_auto(sigmoid, (ccv_nnc_tensor_param_t []){
1680 params,
1681 }, 1, ccv_nnc_no_hint, &output_params, 1);
1682 const ccv_nnc_tensor_symbol_t sigmoid_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1683 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");
1684 outputs[0] = sigmoid_output;
1685}
1686
1687static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context);
1688
1689static const ccv_cnnp_model_vtab_t ccv_cnnp_sigmoid_isa = {
1690 .build = _ccv_cnnp_sigmoid_build,
1691 .copy = _ccv_cnnp_sigmoid_copy,
1692};
1693
1694ccv_cnnp_model_t* ccv_cnnp_sigmoid(const char* const name)
1695{
1696 ccv_cnnp_model_sigmoid_t* const model_sigmoid = (ccv_cnnp_model_sigmoid_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sigmoid_t));
1697 model_sigmoid->super.isa = &ccv_cnnp_sigmoid_isa;
1698 model_sigmoid->super.input_size = 1;
1699 model_sigmoid->super.outputs = &model_sigmoid->output;
1700 model_sigmoid->super.output_size = 1;
1701 ccv_cnnp_model_copy_name(&model_sigmoid->super, name);
1702 return (ccv_cnnp_model_t*)model_sigmoid;
1703}
1704
1705static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context)
1706{
1707 return ccv_cnnp_sigmoid(self->name);
1708}
1709
1710// MARK - Tanh Layer
1711
1712typedef struct {
1713 ccv_cnnp_model_t super;
1714 ccv_nnc_tensor_symbol_t output;
1715} ccv_cnnp_model_tanh_t;
1716
1717static 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)
1718{
1719 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);
1720 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"
, 1720, __extension__ __PRETTY_FUNCTION__); }));
1721 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", 1721, __extension__ __PRETTY_FUNCTION__
); }));
1722 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1723 ccv_nnc_tensor_param_t output_params;
1724 const ccv_nnc_cmd_t tanh = CMD_TANH_FORWARD()ccv_nnc_cmd(CCV_NNC_TANH_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1725 ccv_nnc_hint_tensor_auto(tanh, (ccv_nnc_tensor_param_t []){
1726 params,
1727 }, 1, ccv_nnc_no_hint, &output_params, 1);
1728 const ccv_nnc_tensor_symbol_t tanh_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1729 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");
1730 outputs[0] = tanh_output;
1731}
1732
1733static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context);
1734
1735static const ccv_cnnp_model_vtab_t ccv_cnnp_tanh_isa = {
1736 .build = _ccv_cnnp_tanh_build,
1737 .copy = _ccv_cnnp_tanh_copy,
1738};
1739
1740ccv_cnnp_model_t* ccv_cnnp_tanh(const char* const name)
1741{
1742 ccv_cnnp_model_tanh_t* const model_tanh = (ccv_cnnp_model_tanh_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_tanh_t));
1743 model_tanh->super.isa = &ccv_cnnp_tanh_isa;
1744 model_tanh->super.input_size = 1;
1745 model_tanh->super.outputs = &model_tanh->output;
1746 model_tanh->super.output_size = 1;
1747 ccv_cnnp_model_copy_name(&model_tanh->super, name);
1748 return (ccv_cnnp_model_t*)model_tanh;
1749}
1750
1751static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context)
1752{
1753 return ccv_cnnp_tanh(self->name);
1754}
1755
1756// MARK - Exp Layer
1757
1758typedef struct {
1759 ccv_cnnp_model_t super;
1760 ccv_nnc_tensor_symbol_t output;
1761} ccv_cnnp_model_exp_t;
1762
1763static void _ccv_cnnp_exp_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)
1764{
1765 PRINT(CCV_CLI_VERBOSE, "[cnnp_exp_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_exp_build] -\n"); fflush(stdout); } } while (
0);
1766 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"
, 1766, __extension__ __PRETTY_FUNCTION__); }));
1767 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", 1767, __extension__ __PRETTY_FUNCTION__
); }));
1768 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1769 ccv_nnc_tensor_param_t output_params;
1770 const ccv_nnc_cmd_t exp = CMD_EWEXP_FORWARD()ccv_nnc_cmd(CCV_NNC_EWEXP_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1771 ccv_nnc_hint_tensor_auto(exp, (ccv_nnc_tensor_param_t []){
1772 params,
1773 }, 1, ccv_nnc_no_hint, &output_params, 1);
1774 const ccv_nnc_tensor_symbol_t exp_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1775 ccv_nnc_graph_exec_symbol_new(graph, exp, 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(exp_output)(const ccv_nnc_tensor_symbol_t []){exp_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), "exp");
1776 outputs[0] = exp_output;
1777}
1778
1779static ccv_cnnp_model_t* _ccv_cnnp_exp_copy(const ccv_cnnp_model_t* const self, void* const context);
1780
1781static const ccv_cnnp_model_vtab_t ccv_cnnp_exp_isa = {
1782 .build = _ccv_cnnp_exp_build,
1783 .copy = _ccv_cnnp_exp_copy,
1784};
1785
1786ccv_cnnp_model_t* ccv_cnnp_exp(const char* const name)
1787{
1788 ccv_cnnp_model_exp_t* const model_exp = (ccv_cnnp_model_exp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_exp_t));
1789 model_exp->super.isa = &ccv_cnnp_exp_isa;
1790 model_exp->super.input_size = 1;
1791 model_exp->super.outputs = &model_exp->output;
1792 model_exp->super.output_size = 1;
1793 ccv_cnnp_model_copy_name(&model_exp->super, name);
1794 return (ccv_cnnp_model_t*)model_exp;
1795}
1796
1797static ccv_cnnp_model_t* _ccv_cnnp_exp_copy(const ccv_cnnp_model_t* const self, void* const context)
1798{
1799 return ccv_cnnp_exp(self->name);
1800}
1801
1802// MARK - Softplus Layer
1803
1804typedef struct {
1805 ccv_cnnp_model_t super;
1806 ccv_nnc_tensor_symbol_t output;
1807} ccv_cnnp_model_softplus_t;
1808
1809static void _ccv_cnnp_softplus_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)
1810{
1811 PRINT(CCV_CLI_VERBOSE, "[cnnp_softplus_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_softplus_build] -\n"); fflush(stdout); } } while
(0);
1812 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"
, 1812, __extension__ __PRETTY_FUNCTION__); }));
1813 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", 1813, __extension__ __PRETTY_FUNCTION__
); }));
1814 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1815 ccv_nnc_tensor_param_t output_params;
1816 const ccv_nnc_cmd_t softplus = CMD_EWSOFTPLUS_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSOFTPLUS_FORWARD, 0, ccv_nnc_cmd_auto, 0
);
1817 ccv_nnc_hint_tensor_auto(softplus, (ccv_nnc_tensor_param_t []){
1818 params,
1819 }, 1, ccv_nnc_no_hint, &output_params, 1);
1820 const ccv_nnc_tensor_symbol_t softplus_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1821 ccv_nnc_graph_exec_symbol_new(graph, softplus, 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(softplus_output)(const ccv_nnc_tensor_symbol_t []){softplus_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), "softplus");
1822 outputs[0] = softplus_output;
1823}
1824
1825static ccv_cnnp_model_t* _ccv_cnnp_softplus_copy(const ccv_cnnp_model_t* const self, void* const context);
1826
1827static const ccv_cnnp_model_vtab_t ccv_cnnp_softplus_isa = {
1828 .build = _ccv_cnnp_softplus_build,
1829 .copy = _ccv_cnnp_softplus_copy,
1830};
1831
1832ccv_cnnp_model_t* ccv_cnnp_softplus(const char* const name)
1833{
1834 ccv_cnnp_model_softplus_t* const model_softplus = (ccv_cnnp_model_softplus_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softplus_t));
1835 model_softplus->super.isa = &ccv_cnnp_softplus_isa;
1836 model_softplus->super.input_size = 1;
1837 model_softplus->super.outputs = &model_softplus->output;
1838 model_softplus->super.output_size = 1;
1839 ccv_cnnp_model_copy_name(&model_softplus->super, name);
1840 return (ccv_cnnp_model_t*)model_softplus;
1841}
1842
1843static ccv_cnnp_model_t* _ccv_cnnp_softplus_copy(const ccv_cnnp_model_t* const self, void* const context)
1844{
1845 return ccv_cnnp_softplus(self->name);
1846}
1847
1848// MARK - Swish Layer
1849
1850typedef struct {
1851 ccv_cnnp_model_t super;
1852 ccv_nnc_tensor_symbol_t output;
1853 float beta;
1854} ccv_cnnp_model_swish_t;
1855
1856static 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)
1857{
1858 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);
1859 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"
, 1859, __extension__ __PRETTY_FUNCTION__); }));
1860 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", 1860, __extension__ __PRETTY_FUNCTION__
); }));
1861 ccv_cnnp_model_swish_t* const self = (ccv_cnnp_model_swish_t*)super;
1862 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1863 ccv_nnc_tensor_param_t output_params;
1864 const ccv_nnc_cmd_t swish = CMD_SWISH_FORWARD(self->beta)ccv_nnc_cmd(CCV_NNC_SWISH_FORWARD, 0, ((ccv_nnc_cmd_param_t){
.size={.dim={1,1,1}},.swish={.beta=self->beta}}), 0);
1865 ccv_nnc_hint_tensor_auto(swish, (ccv_nnc_tensor_param_t []){
1866 params,
1867 }, 1, ccv_nnc_no_hint, &output_params, 1);
1868 const ccv_nnc_tensor_symbol_t swish_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1869 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");
1870 outputs[0] = swish_output;
1871}
1872
1873static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context);
1874
1875static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_isa = {
1876 .build = _ccv_cnnp_swish_build,
1877 .copy = _ccv_cnnp_swish_copy,
1878};
1879
1880ccv_cnnp_model_t* ccv_cnnp_swish(const float beta, const char* const name)
1881{
1882 ccv_cnnp_model_swish_t* const model_swish = (ccv_cnnp_model_swish_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swish_t));
1883 model_swish->super.isa = &ccv_cnnp_swish_isa;
1884 model_swish->super.input_size = 1;
1885 model_swish->super.outputs = &model_swish->output;
1886 model_swish->super.output_size = 1;
1887 model_swish->beta = beta;
1888 ccv_cnnp_model_copy_name(&model_swish->super, name);
1889 return (ccv_cnnp_model_t*)model_swish;
1890}
1891
1892static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context)
1893{
1894 const ccv_cnnp_model_swish_t* const swish = (const ccv_cnnp_model_swish_t*)self;
1895 return ccv_cnnp_swish(swish->beta, self->name);
1896}
1897
1898// MARK - Swish Mul Layer
1899
1900typedef struct {
1901 ccv_cnnp_model_t super;
1902 ccv_nnc_tensor_symbol_t output;
1903 float beta;
1904 float scale;
1905} ccv_cnnp_model_swish_mul_t;
1906
1907static void _ccv_cnnp_swish_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)
1908{
1909 PRINT(CCV_CLI_VERBOSE, "[cnnp_swish_mul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_swish_mul_build] -\n"); fflush(stdout); } } while
(0);
1910 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"
, 1910, __extension__ __PRETTY_FUNCTION__); }));
1911 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", 1911, __extension__ __PRETTY_FUNCTION__
); }));
1912 const ccv_cnnp_model_swish_mul_t* const self = (const ccv_cnnp_model_swish_mul_t*)super;
1913 ccv_nnc_tensor_param_t input_params[2];
1914 int i;
1915 for (i = 0; i < 2; i++)
1916 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1917 ccv_nnc_tensor_param_t output_params;
1918 const ccv_nnc_cmd_t swish_mul = CMD_SWISH_MUL_FORWARD(self->beta, self->scale)ccv_nnc_cmd(CCV_NNC_SWISH_MUL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.swish_mul={.beta=self->beta,.scale
=self->scale}}), 0);
1919 ccv_nnc_hint_tensor_auto(swish_mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1920 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1921 ccv_nnc_graph_exec_symbol_new(graph, swish_mul, inputs, input_size, outputs, output_size, "swish_mul");
1922}
1923
1924static ccv_cnnp_model_t* _ccv_cnnp_swish_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
1925
1926static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_mul_isa = {
1927 .build = _ccv_cnnp_swish_mul_build,
1928 .copy = _ccv_cnnp_swish_mul_copy,
1929};
1930
1931ccv_cnnp_model_t* ccv_cnnp_swish_mul(const float beta, const float scale, const char* const name)
1932{
1933 ccv_cnnp_model_swish_mul_t* const model_swish_mul = (ccv_cnnp_model_swish_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swish_mul_t));
1934 model_swish_mul->super.isa = &ccv_cnnp_swish_mul_isa;
1935 model_swish_mul->super.input_size = 2;
1936 model_swish_mul->super.outputs = &model_swish_mul->output;
1937 model_swish_mul->super.output_size = 1;
1938 model_swish_mul->beta = beta;
1939 model_swish_mul->scale = scale;
1940 ccv_cnnp_model_copy_name(&model_swish_mul->super, name);
1941 return (ccv_cnnp_model_t*)model_swish_mul;
1942}
1943
1944static ccv_cnnp_model_t* _ccv_cnnp_swish_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
1945{
1946 const ccv_cnnp_model_swish_mul_t* const self = (const ccv_cnnp_model_swish_mul_t*)super;
1947 return ccv_cnnp_swish_mul(self->beta, self->scale, self->super.name);
1948}
1949
1950// MARK - GELU Layer
1951
1952typedef struct {
1953 ccv_cnnp_model_t super;
1954 ccv_nnc_tensor_symbol_t output;
1955 int tanh;
1956} ccv_cnnp_model_gelu_t;
1957
1958static 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)
1959{
1960 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);
1961 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"
, 1961, __extension__ __PRETTY_FUNCTION__); }));
1962 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", 1962, __extension__ __PRETTY_FUNCTION__
); }));
1963 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1964 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1965 ccv_nnc_tensor_param_t output_params;
1966 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);
1967 ccv_nnc_hint_tensor_auto(gelu, (ccv_nnc_tensor_param_t []){
1968 params,
1969 }, 1, ccv_nnc_no_hint, &output_params, 1);
1970 const ccv_nnc_tensor_symbol_t gelu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1971 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");
1972 outputs[0] = gelu_output;
1973}
1974
1975static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const self, void* const context);
1976
1977static const ccv_cnnp_model_vtab_t ccv_cnnp_gelu_isa = {
1978 .build = _ccv_cnnp_gelu_build,
1979 .copy = _ccv_cnnp_gelu_copy,
1980};
1981
1982ccv_cnnp_model_t* ccv_cnnp_gelu(const int tanh, const char* const name)
1983{
1984 ccv_cnnp_model_gelu_t* const model_gelu = (ccv_cnnp_model_gelu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gelu_t));
1985 model_gelu->super.isa = &ccv_cnnp_gelu_isa;
1986 model_gelu->super.input_size = 1;
1987 model_gelu->super.outputs = &model_gelu->output;
1988 model_gelu->super.output_size = 1;
1989 model_gelu->tanh = tanh;
1990 ccv_cnnp_model_copy_name(&model_gelu->super, name);
1991 return (ccv_cnnp_model_t*)model_gelu;
1992}
1993
1994static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const super, void* const context)
1995{
1996 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1997 return ccv_cnnp_gelu(self->tanh, self->super.name);
1998}
1999
2000// MARK - Leaky ReLU Layer
2001
2002typedef struct {
2003 ccv_cnnp_model_t super;
2004 ccv_nnc_tensor_symbol_t output;
2005 float negative_slope;
2006} ccv_cnnp_model_leaky_relu_t;
2007
2008static 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)
2009{
2010 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);
2011 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"
, 2011, __extension__ __PRETTY_FUNCTION__); }));
2012 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", 2012, __extension__ __PRETTY_FUNCTION__
); }));
2013 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
2014 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2015 ccv_nnc_tensor_param_t output_params;
2016 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);
2017 ccv_nnc_hint_tensor_auto(leaky_relu, (ccv_nnc_tensor_param_t []){
2018 params,
2019 }, 1, ccv_nnc_no_hint, &output_params, 1);
2020 const ccv_nnc_tensor_symbol_t leaky_relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2021 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");
2022 outputs[0] = leaky_relu_output;
2023}
2024
2025static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
2026
2027static const ccv_cnnp_model_vtab_t ccv_cnnp_leaky_relu_isa = {
2028 .build = _ccv_cnnp_leaky_relu_build,
2029 .copy = _ccv_cnnp_leaky_relu_copy,
2030};
2031
2032ccv_cnnp_model_t* ccv_cnnp_leaky_relu(const float negative_slope, const char* const name)
2033{
2034 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));
2035 model_leaky_relu->super.isa = &ccv_cnnp_leaky_relu_isa;
2036 model_leaky_relu->super.input_size = 1;
2037 model_leaky_relu->super.outputs = &model_leaky_relu->output;
2038 model_leaky_relu->super.output_size = 1;
2039 model_leaky_relu->negative_slope = negative_slope;
2040 ccv_cnnp_model_copy_name(&model_leaky_relu->super, name);
2041 return (ccv_cnnp_model_t*)model_leaky_relu;
2042}
2043
2044static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const super, void* const context)
2045{
2046 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
2047 return ccv_cnnp_leaky_relu(self->negative_slope, self->super.name);
2048}
2049
2050// MARK - Softmax Layer
2051
2052typedef struct {
2053 ccv_cnnp_model_t super;
2054 ccv_nnc_tensor_symbol_t output;
2055} ccv_cnnp_model_softmax_t;
2056
2057static 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)
2058{
2059 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);
2060 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"
, 2060, __extension__ __PRETTY_FUNCTION__); }));
2061 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", 2061, __extension__ __PRETTY_FUNCTION__
); }));
2062 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2063 ccv_nnc_tensor_param_t output_params;
2064 const ccv_nnc_cmd_t softmax = CMD_SOFTMAX_FORWARD()ccv_nnc_cmd(CCV_NNC_SOFTMAX_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2065 ccv_nnc_hint_tensor_auto(softmax, (ccv_nnc_tensor_param_t []){
2066 params,
2067 }, 1, ccv_nnc_no_hint, &output_params, 1);
2068 const ccv_nnc_tensor_symbol_t softmax_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2069 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");
2070 outputs[0] = softmax_output;
2071}
2072
2073static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context);
2074
2075static const ccv_cnnp_model_vtab_t ccv_cnnp_softmax_isa = {
2076 .build = _ccv_cnnp_softmax_build,
2077 .copy = _ccv_cnnp_softmax_copy,
2078};
2079
2080ccv_cnnp_model_t* ccv_cnnp_softmax(const char* const name)
2081{
2082 ccv_cnnp_model_softmax_t* const model_softmax = (ccv_cnnp_model_softmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softmax_t));
2083 model_softmax->super.isa = &ccv_cnnp_softmax_isa;
2084 model_softmax->super.input_size = 1;
2085 model_softmax->super.outputs = &model_softmax->output;
2086 model_softmax->super.output_size = 1;
2087 ccv_cnnp_model_copy_name(&model_softmax->super, name);
2088 return (ccv_cnnp_model_t*)model_softmax;
2089}
2090
2091static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context)
2092{
2093 return ccv_cnnp_softmax(self->name);
2094}
2095
2096// MARK - Add Layer
2097
2098typedef struct {
2099 ccv_cnnp_model_t super;
2100 float p;
2101 float q;
2102 ccv_nnc_tensor_symbol_t output;
2103} ccv_cnnp_model_add_t;
2104
2105static 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)
2106{
2107 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);
2108 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
2109 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"
, 2109, __extension__ __PRETTY_FUNCTION__); }));
2110 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", 2110, __extension__ __PRETTY_FUNCTION__
); }));
2111 ccv_nnc_tensor_param_t input_params[2];
2112 int i;
2113 for (i = 0; i < 2; i++)
2114 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2115 ccv_nnc_tensor_param_t output_params;
2116 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);
2117 ccv_nnc_hint_tensor_auto(add, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2118 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2119 ccv_nnc_graph_exec_symbol_new(graph, add, inputs, input_size, outputs, output_size, "add");
2120}
2121
2122static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const self, void* const context);
2123
2124static const ccv_cnnp_model_vtab_t ccv_cnnp_add_isa = {
2125 .build = _ccv_cnnp_add_build,
2126 .copy = _ccv_cnnp_add_copy,
2127};
2128
2129ccv_cnnp_model_t* ccv_cnnp_add(const float p, const float q, const char* const name)
2130{
2131 ccv_cnnp_model_add_t* const model_add = (ccv_cnnp_model_add_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_add_t));
2132 model_add->super.isa = &ccv_cnnp_add_isa;
2133 model_add->super.input_size = 2;
2134 model_add->super.outputs = &model_add->output;
2135 model_add->super.output_size = 1;
2136 model_add->p = p;
2137 model_add->q = q;
2138 ccv_cnnp_model_copy_name(&model_add->super, name);
2139 return (ccv_cnnp_model_t*)model_add;
2140}
2141
2142static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const super, void* const context)
2143{
2144 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
2145 return ccv_cnnp_add(self->p, self->q, self->super.name);
2146}
2147
2148// MARK - Mul Layer
2149
2150typedef struct {
2151 ccv_cnnp_model_t super;
2152 ccv_nnc_tensor_symbol_t output;
2153 float p;
2154} ccv_cnnp_model_mul_t;
2155
2156static 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)
2157{
2158 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);
2159 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2160 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"
, 2160, __extension__ __PRETTY_FUNCTION__); }));
2161 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", 2161, __extension__ __PRETTY_FUNCTION__
); }));
2162 ccv_nnc_tensor_param_t input_params[2];
2163 int i;
2164 for (i = 0; i < 2; i++)
2165 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2166 ccv_nnc_tensor_param_t output_params;
2167 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);
2168 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2169 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2170 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "mul");
2171}
2172
2173static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
2174
2175static const ccv_cnnp_model_vtab_t ccv_cnnp_mul_isa = {
2176 .build = _ccv_cnnp_mul_build,
2177 .copy = _ccv_cnnp_mul_copy,
2178};
2179
2180ccv_cnnp_model_t* ccv_cnnp_mul(const float p, const char* const name)
2181{
2182 ccv_cnnp_model_mul_t* const model_mul = (ccv_cnnp_model_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_mul_t));
2183 model_mul->super.isa = &ccv_cnnp_mul_isa;
2184 model_mul->super.input_size = 2;
2185 model_mul->super.outputs = &model_mul->output;
2186 model_mul->super.output_size = 1;
2187 model_mul->p = p;
2188 ccv_cnnp_model_copy_name(&model_mul->super, name);
2189 return (ccv_cnnp_model_t*)model_mul;
2190}
2191
2192static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2193{
2194 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2195 return ccv_cnnp_mul(self->p, self->super.name);
2196}
2197
2198// MARK - Scalar Mul Layer
2199
2200typedef struct {
2201 ccv_cnnp_model_t super;
2202 ccv_nnc_tensor_symbol_t output;
2203 float a;
2204} ccv_cnnp_model_scalar_mul_t;
2205
2206static 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)
2207{
2208 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);
2209 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"
, 2209, __extension__ __PRETTY_FUNCTION__); }));
2210 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", 2210, __extension__ __PRETTY_FUNCTION__
); }));
2211 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2212 ccv_nnc_tensor_param_t output_params;
2213 ccv_cnnp_model_scalar_mul_t* const self = (ccv_cnnp_model_scalar_mul_t*)super;
2214 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);
2215 ccv_nnc_hint_tensor_auto(scalar_mul, (ccv_nnc_tensor_param_t []){
2216 params,
2217 }, 1, ccv_nnc_no_hint, &output_params, 1);
2218 const ccv_nnc_tensor_symbol_t scalar_mul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2219 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");
2220 outputs[0] = scalar_mul_output;
2221}
2222
2223static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context);
2224
2225static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_mul_isa = {
2226 .build = _ccv_cnnp_scalar_mul_build,
2227 .copy = _ccv_cnnp_scalar_mul_copy,
2228};
2229
2230ccv_cnnp_model_t* ccv_cnnp_scalar_mul(const float a, const char* const name)
2231{
2232 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));
2233 model_scalar_mul->super.isa = &ccv_cnnp_scalar_mul_isa;
2234 model_scalar_mul->super.input_size = 1;
2235 model_scalar_mul->super.outputs = &model_scalar_mul->output;
2236 model_scalar_mul->super.output_size = 1;
2237 model_scalar_mul->a = a;
2238 ccv_cnnp_model_copy_name(&model_scalar_mul->super, name);
2239 return (ccv_cnnp_model_t*)model_scalar_mul;
2240}
2241
2242static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2243{
2244 const ccv_cnnp_model_scalar_mul_t* const self = (const ccv_cnnp_model_scalar_mul_t*)super;
2245 return ccv_cnnp_scalar_mul(self->a, self->super.name);
2246}
2247
2248// MARK - Div Layer
2249
2250typedef struct {
2251 ccv_cnnp_model_t super;
2252 ccv_nnc_tensor_symbol_t output;
2253 int reciprocal;
2254} ccv_cnnp_model_div_t;
2255
2256static 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)
2257{
2258 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2259 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);
2260 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", 2260, __extension__ __PRETTY_FUNCTION__
); }));
2261 ccv_nnc_tensor_param_t input_params[2];
2262 int i;
2263 ccv_nnc_tensor_param_t output_params;
2264 const ccv_nnc_cmd_t div = CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2265 if (self->reciprocal)
2266 {
2267 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"
, 2267, __extension__ __PRETTY_FUNCTION__); }));
2268 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2269 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2270 ccv_nnc_hint_tensor_auto(div, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2271 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2272 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");
2273 } else {
2274 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"
, 2274, __extension__ __PRETTY_FUNCTION__); }));
2275 for (i = 0; i < 2; i++)
2276 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2277 ccv_nnc_hint_tensor_auto(div, input_params, input_size, ccv_nnc_no_hint, &output_params, 1);
2278 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2279 ccv_nnc_graph_exec_symbol_new(graph, div, inputs, input_size, outputs, output_size, "div");
2280 }
2281}
2282
2283static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const self, void* const context);
2284
2285static const ccv_cnnp_model_vtab_t ccv_cnnp_div_isa = {
2286 .build = _ccv_cnnp_div_build,
2287 .copy = _ccv_cnnp_div_copy,
2288};
2289
2290ccv_cnnp_model_t* ccv_cnnp_div(const int reciprocal, const char* const name)
2291{
2292 ccv_cnnp_model_div_t* const model_div = (ccv_cnnp_model_div_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_div_t));
2293 model_div->super.isa = &ccv_cnnp_div_isa;
2294 model_div->super.input_size = reciprocal ? 1 : 2;
2295 model_div->super.outputs = &model_div->output;
2296 model_div->super.output_size = 1;
2297 model_div->reciprocal = reciprocal;
2298 ccv_cnnp_model_copy_name(&model_div->super, name);
2299 return (ccv_cnnp_model_t*)model_div;
2300}
2301
2302static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const super, void* const context)
2303{
2304 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2305 return ccv_cnnp_div(self->reciprocal, self->super.name);
2306}
2307
2308// MARK - Sqrt Layer
2309
2310typedef struct {
2311 ccv_cnnp_model_t super;
2312 ccv_nnc_tensor_symbol_t output;
2313} ccv_cnnp_model_sqrt_t;
2314
2315static 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)
2316{
2317 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);
2318 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", 2318, __extension__ __PRETTY_FUNCTION__
); }));
2319 ccv_nnc_tensor_param_t input_params[1];
2320 ccv_nnc_tensor_param_t output_params;
2321 const ccv_nnc_cmd_t sqrt = CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2322 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"
, 2322, __extension__ __PRETTY_FUNCTION__); }));
2323 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2324 ccv_nnc_hint_tensor_auto(sqrt, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2325 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2326 ccv_nnc_graph_exec_symbol_new(graph, sqrt, inputs, 1, outputs, output_size, "sqrt");
2327}
2328
2329static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const self, void* const context);
2330
2331static const ccv_cnnp_model_vtab_t ccv_cnnp_sqrt_isa = {
2332 .build = _ccv_cnnp_sqrt_build,
2333 .copy = _ccv_cnnp_sqrt_copy,
2334};
2335
2336ccv_cnnp_model_t* ccv_cnnp_sqrt(const char* const name)
2337{
2338 ccv_cnnp_model_sqrt_t* const model_sqrt = (ccv_cnnp_model_sqrt_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sqrt_t));
2339 model_sqrt->super.isa = &ccv_cnnp_sqrt_isa;
2340 model_sqrt->super.input_size = 1;
2341 model_sqrt->super.outputs = &model_sqrt->output;
2342 model_sqrt->super.output_size = 1;
2343 ccv_cnnp_model_copy_name(&model_sqrt->super, name);
2344 return (ccv_cnnp_model_t*)model_sqrt;
2345}
2346
2347static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const super, void* const context)
2348{
2349 const ccv_cnnp_model_sqrt_t* const self = (const ccv_cnnp_model_sqrt_t*)super;
2350 return ccv_cnnp_sqrt(self->super.name);
2351}
2352
2353// MARK - Log Layer
2354
2355typedef struct {
2356 ccv_cnnp_model_t super;
2357 ccv_nnc_tensor_symbol_t output;
2358} ccv_cnnp_model_log_t;
2359
2360static void _ccv_cnnp_log_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)
2361{
2362 PRINT(CCV_CLI_VERBOSE, "[cnnp_log_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_log_build] -\n"); fflush(stdout); } } while (
0);
2363 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", 2363, __extension__ __PRETTY_FUNCTION__
); }));
2364 ccv_nnc_tensor_param_t input_params[1];
2365 ccv_nnc_tensor_param_t output_params;
2366 const ccv_nnc_cmd_t log = CMD_EWLOG_FORWARD()ccv_nnc_cmd(CCV_NNC_EWLOG_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2367 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"
, 2367, __extension__ __PRETTY_FUNCTION__); }));
2368 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2369 ccv_nnc_hint_tensor_auto(log, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2370 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2371 ccv_nnc_graph_exec_symbol_new(graph, log, inputs, 1, outputs, output_size, "log");
2372}
2373
2374static ccv_cnnp_model_t* _ccv_cnnp_log_copy(const ccv_cnnp_model_t* const self, void* const context);
2375
2376static const ccv_cnnp_model_vtab_t ccv_cnnp_log_isa = {
2377 .build = _ccv_cnnp_log_build,
2378 .copy = _ccv_cnnp_log_copy,
2379};
2380
2381ccv_cnnp_model_t* ccv_cnnp_log(const char* const name)
2382{
2383 ccv_cnnp_model_log_t* const model_log = (ccv_cnnp_model_log_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_log_t));
2384 model_log->super.isa = &ccv_cnnp_log_isa;
2385 model_log->super.input_size = 1;
2386 model_log->super.outputs = &model_log->output;
2387 model_log->super.output_size = 1;
2388 ccv_cnnp_model_copy_name(&model_log->super, name);
2389 return (ccv_cnnp_model_t*)model_log;
2390}
2391
2392static ccv_cnnp_model_t* _ccv_cnnp_log_copy(const ccv_cnnp_model_t* const super, void* const context)
2393{
2394 return ccv_cnnp_log(super->name);
2395}
2396
2397// MARK - Pow Layer
2398
2399typedef struct {
2400 ccv_cnnp_model_t super;
2401 ccv_nnc_tensor_symbol_t output;
2402 ccv_nnc_cmd_param_t params;
2403} ccv_cnnp_model_pow_t;
2404
2405static void _ccv_cnnp_pow_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)
2406{
2407 ccv_cnnp_model_pow_t* const self = (ccv_cnnp_model_pow_t*)super;
2408 PRINT(CCV_CLI_VERBOSE, "[cnnp_pow_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_pow_build] -\n"); fflush(stdout); } } while (
0);
2409 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"
, 2409, __extension__ __PRETTY_FUNCTION__); }));
2410 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", 2410, __extension__ __PRETTY_FUNCTION__
); }));
2411 ccv_nnc_tensor_param_t input_params[1];
2412 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2413 ccv_nnc_tensor_param_t output_params;
2414 const ccv_nnc_cmd_t pow = ccv_nnc_cmd(CCV_NNC_EWPOW_FORWARD, 0, self->params, 0);
2415 ccv_nnc_hint_tensor_auto(pow, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2416 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2417 ccv_nnc_graph_exec_symbol_new(graph, pow, inputs, input_size, outputs, output_size, "pow");
2418}
2419
2420static ccv_cnnp_model_t* _ccv_cnnp_pow_copy(const ccv_cnnp_model_t* const self, void* const context);
2421
2422static const ccv_cnnp_model_vtab_t ccv_cnnp_pow_isa = {
2423 .build = _ccv_cnnp_pow_build,
2424 .copy = _ccv_cnnp_pow_copy,
2425};
2426
2427ccv_cnnp_model_t* ccv_cnnp_pow(const float exponent, const char* const name)
2428{
2429 ccv_cnnp_model_pow_t* const model_pow = (ccv_cnnp_model_pow_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pow_t));
2430 model_pow->super.isa = &ccv_cnnp_pow_isa;
2431 model_pow->super.input_size = 1;
2432 model_pow->super.outputs = &model_pow->output;
2433 model_pow->super.output_size = 1;
2434 model_pow->params = (ccv_nnc_cmd_param_t){
2435 .size = {
2436 .dim = { 1, 1, 1 }
2437 },
2438 .pow = {
2439 .exponent = exponent,
2440 },
2441 };
2442 ccv_cnnp_model_copy_name(&model_pow->super, name);
2443 return (ccv_cnnp_model_t*)model_pow;
2444}
2445
2446static ccv_cnnp_model_t* _ccv_cnnp_pow_copy(const ccv_cnnp_model_t* const super, void* const context)
2447{
2448 const ccv_cnnp_model_pow_t* const self = (const ccv_cnnp_model_pow_t*)super;
2449 return ccv_cnnp_pow(self->params.pow.exponent, super->name);
2450}
2451
2452// MARK - Sin Layer
2453
2454typedef struct {
2455 ccv_cnnp_model_t super;
2456 ccv_nnc_tensor_symbol_t output;
2457} ccv_cnnp_model_sin_t;
2458
2459static void _ccv_cnnp_sin_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)
2460{
2461 PRINT(CCV_CLI_VERBOSE, "[cnnp_sin_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sin_build] -\n"); fflush(stdout); } } while (
0);
2462 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", 2462, __extension__ __PRETTY_FUNCTION__
); }));
2463 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"
, 2463, __extension__ __PRETTY_FUNCTION__); }));
2464 ccv_nnc_tensor_param_t input_params[1];
2465 ccv_nnc_tensor_param_t output_params;
2466 const ccv_nnc_cmd_t sin = CMD_EWSIN_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSIN_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2467 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2468 ccv_nnc_hint_tensor_auto(sin, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2469 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2470 ccv_nnc_graph_exec_symbol_new(graph, sin, inputs, 1, outputs, output_size, "sin");
2471}
2472
2473static ccv_cnnp_model_t* _ccv_cnnp_sin_copy(const ccv_cnnp_model_t* const self, void* const context);
2474
2475static const ccv_cnnp_model_vtab_t ccv_cnnp_sin_isa = {
2476 .build = _ccv_cnnp_sin_build,
2477 .copy = _ccv_cnnp_sin_copy,
2478};
2479
2480ccv_cnnp_model_t* ccv_cnnp_sin(const char* const name)
2481{
2482 ccv_cnnp_model_sin_t* const model_sin = (ccv_cnnp_model_sin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sin_t));
2483 model_sin->super.isa = &ccv_cnnp_sin_isa;
2484 model_sin->super.input_size = 1;
2485 model_sin->super.outputs = &model_sin->output;
2486 model_sin->super.output_size = 1;
2487 ccv_cnnp_model_copy_name(&model_sin->super, name);
2488 return (ccv_cnnp_model_t*)model_sin;
2489}
2490
2491static ccv_cnnp_model_t* _ccv_cnnp_sin_copy(const ccv_cnnp_model_t* const super, void* const context)
2492{
2493 return ccv_cnnp_sin(super->name);
2494}
2495
2496// MARK - Cos Layer
2497
2498typedef struct {
2499 ccv_cnnp_model_t super;
2500 ccv_nnc_tensor_symbol_t output;
2501} ccv_cnnp_model_cos_t;
2502
2503static void _ccv_cnnp_cos_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)
2504{
2505 PRINT(CCV_CLI_VERBOSE, "[cnnp_cos_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_cos_build] -\n"); fflush(stdout); } } while (
0);
2506 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", 2506, __extension__ __PRETTY_FUNCTION__
); }));
2507 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"
, 2507, __extension__ __PRETTY_FUNCTION__); }));
2508 ccv_nnc_tensor_param_t input_params[1];
2509 ccv_nnc_tensor_param_t output_params;
2510 const ccv_nnc_cmd_t cos = CMD_EWCOS_FORWARD()ccv_nnc_cmd(CCV_NNC_EWCOS_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2511 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2512 ccv_nnc_hint_tensor_auto(cos, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2513 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2514 ccv_nnc_graph_exec_symbol_new(graph, cos, inputs, 1, outputs, output_size, "cos");
2515}
2516
2517static ccv_cnnp_model_t* _ccv_cnnp_cos_copy(const ccv_cnnp_model_t* const self, void* const context);
2518
2519static const ccv_cnnp_model_vtab_t ccv_cnnp_cos_isa = {
2520 .build = _ccv_cnnp_cos_build,
2521 .copy = _ccv_cnnp_cos_copy,
2522};
2523
2524ccv_cnnp_model_t* ccv_cnnp_cos(const char* const name)
2525{
2526 ccv_cnnp_model_cos_t* const model_cos = (ccv_cnnp_model_cos_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cos_t));
2527 model_cos->super.isa = &ccv_cnnp_cos_isa;
2528 model_cos->super.input_size = 1;
2529 model_cos->super.outputs = &model_cos->output;
2530 model_cos->super.output_size = 1;
2531 ccv_cnnp_model_copy_name(&model_cos->super, name);
2532 return (ccv_cnnp_model_t*)model_cos;
2533}
2534
2535static ccv_cnnp_model_t* _ccv_cnnp_cos_copy(const ccv_cnnp_model_t* const super, void* const context)
2536{
2537 return ccv_cnnp_cos(super->name);
2538}
2539
2540// MARK - Rotate Half Layer
2541
2542typedef struct {
2543 ccv_cnnp_model_t super;
2544 ccv_nnc_tensor_symbol_t output;
2545} ccv_cnnp_model_rotate_half_t;
2546
2547static void _ccv_cnnp_rotate_half_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)
2548{
2549 PRINT(CCV_CLI_VERBOSE, "[cnnp_rotate_half_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_rotate_half_build] -\n"); fflush(stdout); } }
while (0);
2550 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"
, 2550, __extension__ __PRETTY_FUNCTION__); }));
2551 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", 2551, __extension__ __PRETTY_FUNCTION__
); }));
2552 ccv_nnc_tensor_param_t input_params[1];
2553 ccv_nnc_tensor_param_t output_params;
2554 const ccv_nnc_cmd_t rotate_half = CMD_ROTATE_HALF_FORWARD()ccv_nnc_cmd(CCV_NNC_ROTATE_HALF_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}}}, 0);
2555 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2556 ccv_nnc_hint_tensor_auto(rotate_half, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2557 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2558 ccv_nnc_graph_exec_symbol_new(graph, rotate_half, inputs, 1, outputs, output_size, "rotate_half");
2559}
2560
2561static ccv_cnnp_model_t* _ccv_cnnp_rotate_half_copy(const ccv_cnnp_model_t* const self, void* const context);
2562
2563static const ccv_cnnp_model_vtab_t ccv_cnnp_rotate_half_isa = {
2564 .build = _ccv_cnnp_rotate_half_build,
2565 .copy = _ccv_cnnp_rotate_half_copy,
2566};
2567
2568ccv_cnnp_model_t* ccv_cnnp_rotate_half(const char* const name)
2569{
2570 ccv_cnnp_model_rotate_half_t* const model_rotate_half = (ccv_cnnp_model_rotate_half_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rotate_half_t));
2571 model_rotate_half->super.isa = &ccv_cnnp_rotate_half_isa;
2572 model_rotate_half->super.input_size = 1;
2573 model_rotate_half->super.outputs = &model_rotate_half->output;
2574 model_rotate_half->super.output_size = 1;
2575 ccv_cnnp_model_copy_name(&model_rotate_half->super, name);
2576 return (ccv_cnnp_model_t*)model_rotate_half;
2577}
2578
2579static ccv_cnnp_model_t* _ccv_cnnp_rotate_half_copy(const ccv_cnnp_model_t* const super, void* const context)
2580{
2581 return ccv_cnnp_rotate_half(super->name);
2582}
2583
2584// MARK - Walsh-Hadamard Transform Layer
2585
2586typedef struct {
2587 ccv_cnnp_model_t super;
2588 ccv_nnc_tensor_symbol_t output;
2589 float scale;
2590} ccv_cnnp_model_walsh_hadamard_transform_t;
2591
2592static void _ccv_cnnp_walsh_hadamard_transform_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)
2593{
2594 PRINT(CCV_CLI_VERBOSE, "[cnnp_walsh_hadamard_transform_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_walsh_hadamard_transform_build] -\n"); fflush
(stdout); } } while (0);
2595 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"
, 2595, __extension__ __PRETTY_FUNCTION__); }));
2596 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", 2596, __extension__ __PRETTY_FUNCTION__
); }));
2597 const ccv_cnnp_model_walsh_hadamard_transform_t* const self = (const ccv_cnnp_model_walsh_hadamard_transform_t*)super;
2598 ccv_nnc_tensor_param_t input_params[1];
2599 ccv_nnc_tensor_param_t output_params;
2600 const ccv_nnc_cmd_t walsh_hadamard_transform = CMD_WALSH_HADAMARD_TRANSFORM_FORWARD(self->scale)ccv_nnc_cmd(CCV_NNC_WALSH_HADAMARD_TRANSFORM_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.walsh_hadamard_transform={.scale=(self
->scale)}}), 0);
2601 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2602 ccv_nnc_hint_tensor_auto(walsh_hadamard_transform, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2603 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2604 ccv_nnc_graph_exec_symbol_new(graph, walsh_hadamard_transform, inputs, 1, outputs, output_size, "walsh_hadamard_transform");
2605}
2606
2607static ccv_cnnp_model_t* _ccv_cnnp_walsh_hadamard_transform_copy(const ccv_cnnp_model_t* const self, void* const context);
2608
2609static const ccv_cnnp_model_vtab_t ccv_cnnp_walsh_hadamard_transform_isa = {
2610 .build = _ccv_cnnp_walsh_hadamard_transform_build,
2611 .copy = _ccv_cnnp_walsh_hadamard_transform_copy,
2612};
2613
2614ccv_cnnp_model_t* ccv_cnnp_walsh_hadamard_transform(const float scale, const char* const name)
2615{
2616 ccv_cnnp_model_walsh_hadamard_transform_t* const model_walsh_hadamard_transform = (ccv_cnnp_model_walsh_hadamard_transform_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_walsh_hadamard_transform_t));
2617 model_walsh_hadamard_transform->super.isa = &ccv_cnnp_walsh_hadamard_transform_isa;
2618 model_walsh_hadamard_transform->super.input_size = 1;
2619 model_walsh_hadamard_transform->super.outputs = &model_walsh_hadamard_transform->output;
2620 model_walsh_hadamard_transform->super.output_size = 1;
2621 model_walsh_hadamard_transform->scale = scale;
2622 ccv_cnnp_model_copy_name(&model_walsh_hadamard_transform->super, name);
2623 return (ccv_cnnp_model_t*)model_walsh_hadamard_transform;
2624}
2625
2626static ccv_cnnp_model_t* _ccv_cnnp_walsh_hadamard_transform_copy(const ccv_cnnp_model_t* const super, void* const context)
2627{
2628 const ccv_cnnp_model_walsh_hadamard_transform_t* const self = (const ccv_cnnp_model_walsh_hadamard_transform_t*)super;
2629 return ccv_cnnp_walsh_hadamard_transform(self->scale, self->super.name);
2630}
2631
2632// MARK - Hyper Connection Layer
2633
2634typedef struct {
2635 ccv_cnnp_model_t super;
2636 ccv_nnc_tensor_symbol_t outputs[3];
2637 int count;
2638 int sinkhorn_iterations;
2639 float epsilon;
2640 int operation;
2641} ccv_cnnp_model_hyper_connection_t;
2642
2643static void _ccv_cnnp_hyper_connection_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)
2644{
2645 PRINT(CCV_CLI_VERBOSE, "[cnnp_hyper_connection_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_hyper_connection_build] -\n"); fflush(stdout
); } } while (0);
2646 const ccv_cnnp_model_hyper_connection_t* const self = (const ccv_cnnp_model_hyper_connection_t*)super;
2647 assert(input_size == (self->operation == 0 ? 3 : 4))((void) sizeof ((input_size == (self->operation == 0 ? 3 :
4)) ? 1 : 0), __extension__ ({ if (input_size == (self->operation
== 0 ? 3 : 4)) ; else __assert_fail ("input_size == (self->operation == 0 ? 3 : 4)"
, "ccv_cnnp_model_addons.c", 2647, __extension__ __PRETTY_FUNCTION__
); }));
2648 assert(output_size == (self->operation == 2 ? 1 : 3))((void) sizeof ((output_size == (self->operation == 2 ? 1 :
3)) ? 1 : 0), __extension__ ({ if (output_size == (self->
operation == 2 ? 1 : 3)) ; else __assert_fail ("output_size == (self->operation == 2 ? 1 : 3)"
, "ccv_cnnp_model_addons.c", 2648, __extension__ __PRETTY_FUNCTION__
); }));
2649 ccv_nnc_tensor_param_t input_params[4];
2650 int i;
2651 for (i = 0; i < input_size; i++)
2652 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2653 ccv_nnc_tensor_param_t output_params[3];
2654 const ccv_nnc_cmd_t hyper_connection = CMD_HYPER_CONNECTION_FORWARD(self->count, self->sinkhorn_iterations, self->epsilon)ccv_nnc_cmd(CCV_NNC_HYPER_CONNECTION_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.hyper_connection={.count=(self->count
),.sinkhorn_iterations=(self->sinkhorn_iterations),.epsilon
=(self->epsilon)}}), 0);
2655 ccv_nnc_hint_tensor_auto(hyper_connection, input_params, input_size, ccv_nnc_no_hint, output_params, output_size);
2656 for (i = 0; i < output_size; i++)
2657 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
2658 ccv_nnc_graph_exec_symbol_new(graph, hyper_connection, inputs, input_size, outputs, output_size, "hyper_connection");
2659}
2660
2661static ccv_cnnp_model_t* _ccv_cnnp_hyper_connection_copy(const ccv_cnnp_model_t* const self, void* const context);
2662
2663static const ccv_cnnp_model_vtab_t ccv_cnnp_hyper_connection_isa = {
2664 .build = _ccv_cnnp_hyper_connection_build,
2665 .copy = _ccv_cnnp_hyper_connection_copy,
2666};
2667
2668ccv_cnnp_model_t* ccv_cnnp_hyper_connection(const int count, const int sinkhorn_iterations, const float epsilon, const int operation, const char* const name)
2669{
2670 assert(count > 0 && count <= 16)((void) sizeof ((count > 0 && count <= 16) ? 1 :
0), __extension__ ({ if (count > 0 && count <=
16) ; else __assert_fail ("count > 0 && count <= 16"
, "ccv_cnnp_model_addons.c", 2670, __extension__ __PRETTY_FUNCTION__
); }));
2671 assert(sinkhorn_iterations > 0)((void) sizeof ((sinkhorn_iterations > 0) ? 1 : 0), __extension__
({ if (sinkhorn_iterations > 0) ; else __assert_fail ("sinkhorn_iterations > 0"
, "ccv_cnnp_model_addons.c", 2671, __extension__ __PRETTY_FUNCTION__
); }));
2672 assert(epsilon >= 0)((void) sizeof ((epsilon >= 0) ? 1 : 0), __extension__ ({ if
(epsilon >= 0) ; else __assert_fail ("epsilon >= 0", "ccv_cnnp_model_addons.c"
, 2672, __extension__ __PRETTY_FUNCTION__); }));
2673 assert(operation >= 0 && operation <= 2)((void) sizeof ((operation >= 0 && operation <=
2) ? 1 : 0), __extension__ ({ if (operation >= 0 &&
operation <= 2) ; else __assert_fail ("operation >= 0 && operation <= 2"
, "ccv_cnnp_model_addons.c", 2673, __extension__ __PRETTY_FUNCTION__
); }));
2674 ccv_cnnp_model_hyper_connection_t* const model_hyper_connection = (ccv_cnnp_model_hyper_connection_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_hyper_connection_t));
2675 model_hyper_connection->super.isa = &ccv_cnnp_hyper_connection_isa;
2676 model_hyper_connection->super.input_size = operation == 0 ? 3 : 4;
2677 model_hyper_connection->super.outputs = model_hyper_connection->outputs;
2678 model_hyper_connection->super.output_size = operation == 2 ? 1 : 3;
2679 model_hyper_connection->count = count;
2680 model_hyper_connection->sinkhorn_iterations = sinkhorn_iterations;
2681 model_hyper_connection->epsilon = epsilon;
2682 model_hyper_connection->operation = operation;
2683 ccv_cnnp_model_copy_name(&model_hyper_connection->super, name);
2684 return (ccv_cnnp_model_t*)model_hyper_connection;
2685}
2686
2687static ccv_cnnp_model_t* _ccv_cnnp_hyper_connection_copy(const ccv_cnnp_model_t* const super, void* const context)
2688{
2689 const ccv_cnnp_model_hyper_connection_t* const self = (const ccv_cnnp_model_hyper_connection_t*)super;
2690 return ccv_cnnp_hyper_connection(self->count, self->sinkhorn_iterations, self->epsilon, self->operation, self->super.name);
2691}
2692
2693// MARK - Gated Delta Layer
2694
2695typedef struct {
2696 ccv_cnnp_model_t super;
2697 ccv_nnc_tensor_symbol_t outputs[2];
2698 int log_decay;
2699 int state_checkpoint_count;
2700} ccv_cnnp_model_gated_delta_t;
2701
2702static void _ccv_cnnp_gated_delta_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
2703{
2704 PRINT(CCV_CLI_VERBOSE, "[cnnp_gated_delta_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_gated_delta_build] -\n"); fflush(stdout); } }
while (0);
2705 ccv_cnnp_model_gated_delta_t* const self = (ccv_cnnp_model_gated_delta_t*)super;
2706 assert(input_size == 6)((void) sizeof ((input_size == 6) ? 1 : 0), __extension__ ({ if
(input_size == 6) ; else __assert_fail ("input_size == 6", "ccv_cnnp_model_addons.c"
, 2706, __extension__ __PRETTY_FUNCTION__); }));
2707 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", 2707, __extension__ __PRETTY_FUNCTION__
); }));
2708 ccv_nnc_tensor_param_t input_params[6];
2709 int i;
2710 for (i = 0; i < 6; i++)
2711 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2712 ccv_nnc_tensor_param_t output_params[2];
2713 const ccv_nnc_cmd_t gated_delta = CMD_GATED_DELTA_FORWARD(self->log_decay, self->state_checkpoint_count)ccv_nnc_cmd(CCV_NNC_GATED_DELTA_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.gated_delta={.log_decay=(self->log_decay
),.state_checkpoint_count=(self->state_checkpoint_count)}}
), 0);
2714 ccv_nnc_hint_tensor_auto(gated_delta, input_params, 6, ccv_nnc_no_hint, output_params, 2);
2715 for (i = 0; i < 2; i++)
2716 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
2717 ccv_nnc_graph_exec_symbol_new(graph, gated_delta, inputs, input_size, outputs, output_size, "gated_delta");
2718}
2719
2720static ccv_cnnp_model_t* _ccv_cnnp_gated_delta_copy(const ccv_cnnp_model_t* const self, void* const context);
2721
2722static const ccv_cnnp_model_vtab_t ccv_cnnp_gated_delta_isa = {
2723 .build = _ccv_cnnp_gated_delta_build,
2724 .copy = _ccv_cnnp_gated_delta_copy,
2725};
2726
2727ccv_cnnp_model_t* ccv_cnnp_gated_delta(const int log_decay, const int state_checkpoint_count, const char* const name)
2728{
2729 ccv_cnnp_model_gated_delta_t* const model_gated_delta = (ccv_cnnp_model_gated_delta_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gated_delta_t));
2730 model_gated_delta->super.isa = &ccv_cnnp_gated_delta_isa;
2731 model_gated_delta->super.input_size = 6;
2732 model_gated_delta->super.outputs = model_gated_delta->outputs;
2733 model_gated_delta->super.output_size = 2;
2734 model_gated_delta->log_decay = log_decay;
2735 model_gated_delta->state_checkpoint_count = state_checkpoint_count;
2736 ccv_cnnp_model_copy_name(&model_gated_delta->super, name);
2737 return (ccv_cnnp_model_t*)model_gated_delta;
2738}
2739
2740static ccv_cnnp_model_t* _ccv_cnnp_gated_delta_copy(const ccv_cnnp_model_t* const super, void* const context)
2741{
2742 const ccv_cnnp_model_gated_delta_t* const self = (const ccv_cnnp_model_gated_delta_t*)super;
2743 return ccv_cnnp_gated_delta(self->log_decay, self->state_checkpoint_count, super->name);
2744}
2745
2746// MARK - Cmul Layer
2747
2748typedef struct {
2749 ccv_cnnp_model_t super;
2750 ccv_nnc_tensor_symbol_t output;
2751 int conjugate;
2752} ccv_cnnp_model_cmul_t;
2753
2754static 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)
2755{
2756 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);
2757 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"
, 2757, __extension__ __PRETTY_FUNCTION__); }));
2758 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", 2758, __extension__ __PRETTY_FUNCTION__
); }));
2759 ccv_nnc_tensor_param_t input_params[2];
2760 int i;
2761 for (i = 0; i < 2; i++)
2762 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2763 ccv_nnc_tensor_param_t output_params;
2764 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);
2765 mul.info.cmul.conjugate = ((ccv_cnnp_model_cmul_t*)super)->conjugate;
2766 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2767 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2768 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "cmul");
2769}
2770
2771static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const self, void* const context);
2772
2773static const ccv_cnnp_model_vtab_t ccv_cnnp_cmul_isa = {
2774 .build = _ccv_cnnp_cmul_build,
2775 .copy = _ccv_cnnp_cmul_copy,
2776};
2777
2778ccv_cnnp_model_t* ccv_cnnp_cmul(const int conjugate, const char* const name)
2779{
2780 assert(conjugate == 0 || conjugate == 1)((void) sizeof ((conjugate == 0 || conjugate == 1) ? 1 : 0), __extension__
({ if (conjugate == 0 || conjugate == 1) ; else __assert_fail
("conjugate == 0 || conjugate == 1", "ccv_cnnp_model_addons.c"
, 2780, __extension__ __PRETTY_FUNCTION__); }));
2781 ccv_cnnp_model_cmul_t* const model_cmul = (ccv_cnnp_model_cmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cmul_t));
2782 model_cmul->super.isa = &ccv_cnnp_cmul_isa;
2783 model_cmul->super.input_size = 2;
2784 model_cmul->super.outputs = &model_cmul->output;
2785 model_cmul->super.output_size = 1;
2786 model_cmul->conjugate = conjugate;
2787 ccv_cnnp_model_copy_name(&model_cmul->super, name);
2788 return (ccv_cnnp_model_t*)model_cmul;
2789}
2790
2791static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2792{
2793 const ccv_cnnp_model_cmul_t* const self = (const ccv_cnnp_model_cmul_t*)super;
2794 return ccv_cnnp_cmul(self->conjugate, super->name);
2795}
2796
2797// MARK - Transpose Layer
2798
2799typedef struct {
2800 ccv_cnnp_model_t super;
2801 ccv_nnc_tensor_symbol_t output;
2802 int transpose[2];
2803} ccv_cnnp_model_transpose_t;
2804
2805static 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)
2806{
2807 ccv_cnnp_model_transpose_t* const self = (ccv_cnnp_model_transpose_t*)super;
2808 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);
2809 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"
, 2809, __extension__ __PRETTY_FUNCTION__); }));
2810 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", 2810, __extension__ __PRETTY_FUNCTION__
); }));
2811 if (self->transpose[0] == self->transpose[1])
2812 {
2813 outputs[0] = inputs[0];
2814 return;
2815 }
2816 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2817 ccv_nnc_tensor_param_t output_params;
2818 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);
2819 ccv_nnc_hint_tensor_auto(transpose, (ccv_nnc_tensor_param_t []){
2820 params,
2821 }, 1, ccv_nnc_no_hint, &output_params, 1);
2822 const ccv_nnc_tensor_symbol_t transpose_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2823 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");
2824 outputs[0] = transpose_output;
2825}
2826
2827static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
2828
2829static const ccv_cnnp_model_vtab_t ccv_cnnp_transpose_isa = {
2830 .build = _ccv_cnnp_transpose_build,
2831 .copy = _ccv_cnnp_transpose_copy,
2832};
2833
2834ccv_cnnp_model_t* ccv_cnnp_transpose(const int axis_a, const int axis_b, const char* const name)
2835{
2836 ccv_cnnp_model_transpose_t* const model_transpose = (ccv_cnnp_model_transpose_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_transpose_t));
2837 model_transpose->super.isa = &ccv_cnnp_transpose_isa;
2838 model_transpose->super.input_size = 1;
2839 model_transpose->super.outputs = &model_transpose->output;
2840 model_transpose->super.output_size = 1;
2841 model_transpose->transpose[0] = axis_a;
2842 model_transpose->transpose[1] = axis_b;
2843 ccv_cnnp_model_copy_name(&model_transpose->super, name);
2844 return (ccv_cnnp_model_t*)model_transpose;
2845}
2846
2847static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
2848{
2849 const ccv_cnnp_model_transpose_t* const self = (const ccv_cnnp_model_transpose_t*)super;
2850 return ccv_cnnp_transpose(self->transpose[0], self->transpose[1], self->super.name);
2851}
2852
2853// MARK - Layer Norm Layer
2854
2855typedef struct {
2856 ccv_cnnp_model_t super;
2857 ccv_nnc_tensor_symbol_t output;
2858 ccv_nnc_tensor_symbol_t bias;
2859 ccv_nnc_tensor_symbol_t scale;
2860 ccv_nnc_cmd_param_t params;
2861} ccv_cnnp_model_layer_norm_t;
2862
2863static 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)
2864{
2865 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);
2866 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"
, 2866, __extension__ __PRETTY_FUNCTION__); }));
2867 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", 2867, __extension__ __PRETTY_FUNCTION__
); }));
2868 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2869 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2870 ccv_nnc_tensor_param_t bias_params = params;
2871 const int nd = ccv_nnc_tensor_nd(params.dim);
2872 int i;
2873 for (i = 0; i < nd; i++)
2874 bias_params.dim[i] = 1;
2875 for (i = 0; i < self->params.lnorm.count; i++)
2876 bias_params.dim[self->params.lnorm.axis[i]] = params.dim[self->params.lnorm.axis[i]];
2877 if (self->params.lnorm.elementwise_affine)
2878 {
2879 // Both scale and bias are shared between if this model is reused.
2880 if (!self->scale.graph)
2881 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2882 if (!self->bias.graph)
2883 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2884 }
2885 const ccv_nnc_tensor_symbol_t scale = self->params.lnorm.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->scale) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
2886 const ccv_nnc_tensor_symbol_t bias = self->params.lnorm.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->bias) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
2887 const ccv_nnc_cmd_t layer_norm = ccv_nnc_cmd(CCV_NNC_LAYER_NORM_FORWARD, 0, self->params, 0);
2888 ccv_nnc_tensor_param_t output_params[3];
2889 if (self->params.lnorm.elementwise_affine)
2890 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2891 params,
2892 bias_params,
2893 bias_params,
2894 }, 3, ccv_nnc_no_hint, output_params, 3);
2895 else
2896 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
2897 params,
2898 }, 1, ccv_nnc_no_hint, output_params, 3);
2899 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2900 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
2901 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
2902 if (self->params.lnorm.elementwise_affine)
2903 ccv_nnc_graph_exec_symbol_new(graph, layer_norm, TENSOR_SYMBOL_LIST(inputs[0], scale, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], scale, 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");
2904 else
2905 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");
2906 outputs[0] = output;
2907}
2908
2909static 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)
2910{
2911 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2912 if (self->scale.graph)
2913 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);
2914 if (self->bias.graph)
2915 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);
2916}
2917
2918static 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)
2919{
2920 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
2921 if (self->scale.graph)
2922 add_to_array(parameters, self->scale, is_trainable);
2923 if (self->bias.graph)
2924 add_to_array(parameters, self->bias, is_trainable);
2925}
2926
2927static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
2928
2929static const ccv_cnnp_model_vtab_t ccv_cnnp_layer_norm_isa = {
2930 .build = _ccv_cnnp_layer_norm_build,
2931 .init_states = _ccv_cnnp_layer_norm_init_states,
2932 .add_to_parameter = _ccv_cnnp_layer_norm_add_to_parameter,
2933 .copy = _ccv_cnnp_layer_norm_copy,
2934};
2935
2936ccv_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 float scale, const int is_trainable, const char* const name)
2937{
2938 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));
2939 model_layer_norm->super.isa = &ccv_cnnp_layer_norm_isa;
2940 model_layer_norm->super.input_size = 1;
2941 model_layer_norm->super.outputs = &model_layer_norm->output;
2942 model_layer_norm->super.output_size = 1;
2943 model_layer_norm->super.is_trainable = is_trainable;
2944 ccv_cnnp_model_copy_name(&model_layer_norm->super, name);
2945 model_layer_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
2946 model_layer_norm->scale.graph = 0;
2947 model_layer_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
2948 model_layer_norm->bias.graph = 0;
2949 model_layer_norm->params.lnorm.epsilon = epsilon;
2950 model_layer_norm->params.lnorm.scale = scale;
2951 model_layer_norm->params.lnorm.count = axis_count;
2952 model_layer_norm->params.lnorm.elementwise_affine = elementwise_affine;
2953 memcpy(model_layer_norm->params.lnorm.axis, axis, sizeof(int) * axis_count);
2954 return (ccv_cnnp_model_t*)model_layer_norm;
2955}
2956
2957static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
2958{
2959 const ccv_cnnp_model_layer_norm_t* const self = (const ccv_cnnp_model_layer_norm_t*)super;
2960 return ccv_cnnp_layer_norm(self->params.lnorm.epsilon, self->params.lnorm.axis, self->params.lnorm.count, self->params.lnorm.elementwise_affine, self->params.lnorm.scale, self->super.is_trainable, self->super.name);
2961}
2962
2963// MARK - Group Norm Layer
2964
2965typedef struct {
2966 ccv_cnnp_model_t super;
2967 ccv_nnc_tensor_symbol_t output;
2968 ccv_nnc_tensor_symbol_t bias;
2969 ccv_nnc_tensor_symbol_t scale;
2970 ccv_nnc_cmd_param_t params;
2971} ccv_cnnp_model_group_norm_t;
2972
2973static 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)
2974{
2975 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);
2976 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"
, 2976, __extension__ __PRETTY_FUNCTION__); }));
2977 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", 2977, __extension__ __PRETTY_FUNCTION__
); }));
2978 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
2979 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2980 ccv_nnc_tensor_param_t bias_params = params;
2981 const int nd = ccv_nnc_tensor_nd(params.dim);
2982 int i;
2983 for (i = 0; i < nd; i++)
2984 bias_params.dim[i] = 1;
2985 bias_params.dim[self->params.gnorm.group_axis] = params.dim[self->params.gnorm.group_axis];
2986 if (self->params.gnorm.elementwise_affine)
2987 {
2988 // Both scale and bias are shared between if this model is reused.
2989 if (!self->scale.graph)
2990 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
2991 if (!self->bias.graph)
2992 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
2993 }
2994 const ccv_nnc_tensor_symbol_t scale = self->params.gnorm.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->scale) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
2995 const ccv_nnc_tensor_symbol_t bias = self->params.gnorm.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->bias) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
2996 const ccv_nnc_cmd_t group_norm = ccv_nnc_cmd(CCV_NNC_GROUP_NORM_FORWARD, 0, self->params, 0);
2997 ccv_nnc_tensor_param_t output_params[3];
2998 if (self->params.gnorm.elementwise_affine)
2999 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
3000 params,
3001 bias_params,
3002 bias_params,
3003 }, 3, ccv_nnc_no_hint, output_params, 3);
3004 else
3005 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
3006 params,
3007 }, 1, ccv_nnc_no_hint, output_params, 3);
3008 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3009 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
3010 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
3011 if (self->params.gnorm.elementwise_affine)
3012 ccv_nnc_graph_exec_symbol_new(graph, group_norm, TENSOR_SYMBOL_LIST(inputs[0], scale, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], scale, 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");
3013 else
3014 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");
3015 outputs[0] = output;
3016}
3017
3018static 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)
3019{
3020 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
3021 if (self->scale.graph)
3022 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);
3023 if (self->bias.graph)
3024 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);
3025}
3026
3027static 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)
3028{
3029 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
3030 if (self->scale.graph)
3031 add_to_array(parameters, self->scale, is_trainable);
3032 if (self->bias.graph)
3033 add_to_array(parameters, self->bias, is_trainable);
3034}
3035
3036static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
3037
3038static const ccv_cnnp_model_vtab_t ccv_cnnp_group_norm_isa = {
3039 .build = _ccv_cnnp_group_norm_build,
3040 .init_states = _ccv_cnnp_group_norm_init_states,
3041 .add_to_parameter = _ccv_cnnp_group_norm_add_to_parameter,
3042 .copy = _ccv_cnnp_group_norm_copy,
3043};
3044
3045ccv_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)
3046{
3047 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));
3048 model_group_norm->super.isa = &ccv_cnnp_group_norm_isa;
3049 model_group_norm->super.input_size = 1;
3050 model_group_norm->super.outputs = &model_group_norm->output;
3051 model_group_norm->super.output_size = 1;
3052 model_group_norm->super.is_trainable = is_trainable;
3053 ccv_cnnp_model_copy_name(&model_group_norm->super, name);
3054 model_group_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3055 model_group_norm->scale.graph = 0;
3056 model_group_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
3057 model_group_norm->bias.graph = 0;
3058 model_group_norm->params.gnorm.group_axis = group_axis;
3059 model_group_norm->params.gnorm.groups = groups;
3060 model_group_norm->params.gnorm.epsilon = epsilon;
3061 model_group_norm->params.gnorm.reduce_count = axis_count;
3062 model_group_norm->params.gnorm.elementwise_affine = elementwise_affine;
3063 memcpy(model_group_norm->params.gnorm.reduce_axis, reduce_axis, sizeof(int) * axis_count);
3064 return (ccv_cnnp_model_t*)model_group_norm;
3065}
3066
3067static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
3068{
3069 const ccv_cnnp_model_group_norm_t* const self = (const ccv_cnnp_model_group_norm_t*)super;
3070 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);
3071}
3072
3073// MARK - RMSNorm Layer
3074
3075typedef struct {
3076 ccv_cnnp_model_t super;
3077 ccv_nnc_tensor_symbol_t output;
3078 ccv_nnc_tensor_symbol_t scale;
3079 ccv_nnc_cmd_param_t params;
3080} ccv_cnnp_model_rmsnorm_t;
3081
3082static 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)
3083{
3084 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);
3085 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"
, 3085, __extension__ __PRETTY_FUNCTION__); }));
3086 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", 3086, __extension__ __PRETTY_FUNCTION__
); }));
3087 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3088 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3089 ccv_nnc_tensor_param_t scale_params = params;
3090 const int nd = ccv_nnc_tensor_nd(params.dim);
3091 int i;
3092 for (i = 0; i < nd; i++)
3093 scale_params.dim[i] = 1;
3094 for (i = 0; i < self->params.rmsnorm.count; i++)
3095 scale_params.dim[self->params.rmsnorm.axis[i]] = params.dim[self->params.rmsnorm.axis[i]];
3096 // Both scale and bias are shared between if this model is reused.
3097 if (self->params.rmsnorm.elementwise_affine)
3098 {
3099 if (!self->scale.graph)
3100 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3101 }
3102 const ccv_nnc_tensor_symbol_t scale = self->params.rmsnorm.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->scale) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3103 const ccv_nnc_cmd_t rmsnorm = ccv_nnc_cmd(CCV_NNC_RMSNORM_FORWARD, 0, self->params, 0);
3104 ccv_nnc_tensor_param_t output_params[2];
3105 if (self->params.rmsnorm.elementwise_affine)
3106 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
3107 params,
3108 scale_params,
3109 }, 2, ccv_nnc_no_hint, output_params, 2);
3110 else
3111 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
3112 params,
3113 }, 1, ccv_nnc_no_hint, output_params, 2);
3114 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3115 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_inv_std");
3116 if (self->params.rmsnorm.elementwise_affine)
3117 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm, TENSOR_SYMBOL_LIST(inputs[0], scale)(const ccv_nnc_tensor_symbol_t []){inputs[0], 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");
3118 else
3119 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm, 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_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");
3120 outputs[0] = output;
3121}
3122
3123static 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)
3124{
3125 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3126 if (self->scale.graph)
3127 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);
3128}
3129
3130static 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)
3131{
3132 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3133 if (self->scale.graph)
3134 add_to_array(parameters, self->scale, is_trainable);
3135}
3136
3137static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context);
3138
3139static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_isa = {
3140 .build = _ccv_cnnp_rmsnorm_build,
3141 .init_states = _ccv_cnnp_rmsnorm_init_states,
3142 .add_to_parameter = _ccv_cnnp_rmsnorm_add_to_parameter,
3143 .copy = _ccv_cnnp_rmsnorm_copy,
3144};
3145
3146ccv_cnnp_model_t* ccv_cnnp_rmsnorm(const float epsilon, const int axis[CCV_NNC_MAX_DIM_ALLOC(12)], const int axis_count, const int elementwise_affine, const float scale, const int is_trainable, const char* const name)
3147{
3148 ccv_cnnp_model_rmsnorm_t* const model_rmsnorm = (ccv_cnnp_model_rmsnorm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_t));
3149 model_rmsnorm->super.isa = &ccv_cnnp_rmsnorm_isa;
3150 model_rmsnorm->super.input_size = 1;
3151 model_rmsnorm->super.outputs = &model_rmsnorm->output;
3152 model_rmsnorm->super.output_size = 1;
3153 model_rmsnorm->super.is_trainable = is_trainable;
3154 ccv_cnnp_model_copy_name(&model_rmsnorm->super, name);
3155 model_rmsnorm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3156 model_rmsnorm->scale.graph = 0;
3157 model_rmsnorm->params.rmsnorm.epsilon = epsilon;
3158 model_rmsnorm->params.rmsnorm.scale = scale;
3159 model_rmsnorm->params.rmsnorm.count = axis_count;
3160 model_rmsnorm->params.rmsnorm.elementwise_affine = elementwise_affine;
3161 memcpy(model_rmsnorm->params.lnorm.axis, axis, sizeof(int) * axis_count);
3162 return (ccv_cnnp_model_t*)model_rmsnorm;
3163}
3164
3165static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context)
3166{
3167 const ccv_cnnp_model_rmsnorm_t* const self = (const ccv_cnnp_model_rmsnorm_t*)super;
3168 return ccv_cnnp_rmsnorm(self->params.rmsnorm.epsilon, self->params.rmsnorm.axis, self->params.rmsnorm.count, self->params.rmsnorm.elementwise_affine, self->params.rmsnorm.scale, self->super.is_trainable, self->super.name);
3169}
3170
3171// MARK - RMSNorm CMul Layer
3172
3173typedef struct {
3174 ccv_cnnp_model_t super;
3175 ccv_nnc_tensor_symbol_t output;
3176 ccv_nnc_tensor_symbol_t scale;
3177 ccv_nnc_cmd_param_t params;
3178} ccv_cnnp_model_rmsnorm_cmul_t;
3179
3180static void _ccv_cnnp_rmsnorm_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)
3181{
3182 PRINT(CCV_CLI_VERBOSE, "[cnnp_rmsnorm_cmul_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_rmsnorm_cmul_build] -\n"); fflush(stdout); }
} while (0);
3183 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"
, 3183, __extension__ __PRETTY_FUNCTION__); }));
3184 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", 3184, __extension__ __PRETTY_FUNCTION__
); }));
3185 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3186 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3187 const ccv_nnc_tensor_param_t rotation_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3188 ccv_nnc_tensor_param_t scale_params = params;
3189 const int nd = ccv_nnc_tensor_nd(params.dim);
3190 int i;
3191 for (i = 0; i < nd; i++)
3192 scale_params.dim[i] = 1;
3193 for (i = 0; i < self->params.rmsnorm_cmul.count; i++)
3194 scale_params.dim[self->params.rmsnorm_cmul.axis[i]] = params.dim[self->params.rmsnorm_cmul.axis[i]];
3195 if (self->params.rmsnorm_cmul.elementwise_affine)
3196 {
3197 if (!self->scale.graph)
3198 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3199 }
3200 const ccv_nnc_tensor_symbol_t scale = self->params.rmsnorm_cmul.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->scale) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3201 const ccv_nnc_cmd_t rmsnorm_cmul = ccv_nnc_cmd(CCV_NNC_RMSNORM_CMUL_FORWARD, 0, self->params, 0);
3202 ccv_nnc_tensor_param_t output_params;
3203 if (self->params.rmsnorm_cmul.elementwise_affine)
3204 ccv_nnc_hint_tensor_auto(rmsnorm_cmul, (ccv_nnc_tensor_param_t []){
3205 params,
3206 rotation_params,
3207 scale_params,
3208 }, 3, ccv_nnc_no_hint, &output_params, 1);
3209 else
3210 ccv_nnc_hint_tensor_auto(rmsnorm_cmul, (ccv_nnc_tensor_param_t []){
3211 params,
3212 rotation_params,
3213 }, 2, ccv_nnc_no_hint, &output_params, 1);
3214 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3215 if (self->params.rmsnorm_cmul.elementwise_affine)
3216 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_cmul, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], scale)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], scale
}, (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), outputs, output_size, "rmsnorm_cmul");
3217 else
3218 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_cmul, inputs, input_size, outputs, output_size, "rmsnorm_cmul");
3219}
3220
3221static void _ccv_cnnp_rmsnorm_cmul_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)
3222{
3223 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3224 if (self->scale.graph)
3225 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);
3226}
3227
3228static void _ccv_cnnp_rmsnorm_cmul_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)
3229{
3230 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3231 if (self->scale.graph)
3232 add_to_array(parameters, self->scale, is_trainable);
3233}
3234
3235static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_cmul_copy(const ccv_cnnp_model_t* const super, void* const context);
3236
3237static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_cmul_isa = {
3238 .build = _ccv_cnnp_rmsnorm_cmul_build,
3239 .init_states = _ccv_cnnp_rmsnorm_cmul_init_states,
3240 .add_to_parameter = _ccv_cnnp_rmsnorm_cmul_add_to_parameter,
3241 .copy = _ccv_cnnp_rmsnorm_cmul_copy,
3242};
3243
3244ccv_cnnp_model_t* ccv_cnnp_rmsnorm_cmul(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)
3245{
3246 ccv_cnnp_model_rmsnorm_cmul_t* const model_rmsnorm_cmul = (ccv_cnnp_model_rmsnorm_cmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_cmul_t));
3247 model_rmsnorm_cmul->super.isa = &ccv_cnnp_rmsnorm_cmul_isa;
3248 model_rmsnorm_cmul->super.input_size = 2;
3249 model_rmsnorm_cmul->super.outputs = &model_rmsnorm_cmul->output;
3250 model_rmsnorm_cmul->super.output_size = 1;
3251 model_rmsnorm_cmul->super.is_trainable = is_trainable;
3252 ccv_cnnp_model_copy_name(&model_rmsnorm_cmul->super, name);
3253 model_rmsnorm_cmul->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3254 model_rmsnorm_cmul->scale.graph = 0;
3255 model_rmsnorm_cmul->params.rmsnorm_cmul.epsilon = epsilon;
3256 model_rmsnorm_cmul->params.rmsnorm_cmul.count = axis_count;
3257 model_rmsnorm_cmul->params.rmsnorm_cmul.elementwise_affine = elementwise_affine;
3258 memcpy(model_rmsnorm_cmul->params.rmsnorm_cmul.axis, axis, sizeof(int) * axis_count);
3259 return (ccv_cnnp_model_t*)model_rmsnorm_cmul;
3260}
3261
3262static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
3263{
3264 const ccv_cnnp_model_rmsnorm_cmul_t* const self = (const ccv_cnnp_model_rmsnorm_cmul_t*)super;
3265 return ccv_cnnp_rmsnorm_cmul(self->params.rmsnorm_cmul.epsilon, self->params.rmsnorm_cmul.axis, self->params.rmsnorm_cmul.count, self->params.rmsnorm_cmul.elementwise_affine, self->super.is_trainable, self->super.name);
3266}
3267
3268// MARK - RMSNorm Gated Layer
3269
3270typedef struct {
3271 ccv_cnnp_model_t super;
3272 ccv_nnc_tensor_symbol_t output;
3273 ccv_nnc_tensor_symbol_t scale;
3274 ccv_nnc_cmd_param_t params;
3275} ccv_cnnp_model_rmsnorm_gated_t;
3276
3277static void _ccv_cnnp_rmsnorm_gated_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)
3278{
3279 PRINT(CCV_CLI_VERBOSE, "[cnnp_rmsnorm_gated_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_rmsnorm_gated_build] -\n"); fflush(stdout); }
} while (0);
3280 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"
, 3280, __extension__ __PRETTY_FUNCTION__); }));
3281 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", 3281, __extension__ __PRETTY_FUNCTION__
); }));
3282 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3283 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3284 const ccv_nnc_tensor_param_t gate_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3285 ccv_nnc_tensor_param_t scale_params = params;
3286 const int nd = ccv_nnc_tensor_nd(params.dim);
3287 int i;
3288 for (i = 0; i < nd; i++)
3289 scale_params.dim[i] = 1;
3290 for (i = 0; i < self->params.rmsnorm_gated.count; i++)
3291 scale_params.dim[self->params.rmsnorm_gated.axis[i]] = params.dim[self->params.rmsnorm_gated.axis[i]];
3292 if (self->params.rmsnorm_gated.elementwise_affine)
3293 {
3294 if (!self->scale.graph)
3295 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3296 }
3297 const ccv_nnc_tensor_symbol_t scale = self->params.rmsnorm_gated.elementwise_affine ? ccv_cnnp_model_get_symbol(super, self->scale) : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
3298 const ccv_nnc_cmd_t rmsnorm_gated = ccv_nnc_cmd(CCV_NNC_RMSNORM_GATED_FORWARD, 0, self->params, 0);
3299 ccv_nnc_tensor_param_t output_params;
3300 if (self->params.rmsnorm_gated.elementwise_affine)
3301 ccv_nnc_hint_tensor_auto(rmsnorm_gated, (ccv_nnc_tensor_param_t []){
3302 params,
3303 gate_params,
3304 scale_params,
3305 }, 3, ccv_nnc_no_hint, &output_params, 1);
3306 else
3307 ccv_nnc_hint_tensor_auto(rmsnorm_gated, (ccv_nnc_tensor_param_t []){
3308 params,
3309 gate_params,
3310 }, 2, ccv_nnc_no_hint, &output_params, 1);
3311 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3312 if (self->params.rmsnorm_gated.elementwise_affine)
3313 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_gated, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], scale)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], scale
}, (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), outputs, output_size, "rmsnorm_gated");
3314 else
3315 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_gated, inputs, input_size, outputs, output_size, "rmsnorm_gated");
3316}
3317
3318static void _ccv_cnnp_rmsnorm_gated_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)
3319{
3320 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3321 if (self->scale.graph)
3322 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);
3323}
3324
3325static void _ccv_cnnp_rmsnorm_gated_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)
3326{
3327 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3328 if (self->scale.graph)
3329 add_to_array(parameters, self->scale, is_trainable);
3330}
3331
3332static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_gated_copy(const ccv_cnnp_model_t* const super, void* const context);
3333
3334static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_gated_isa = {
3335 .build = _ccv_cnnp_rmsnorm_gated_build,
3336 .init_states = _ccv_cnnp_rmsnorm_gated_init_states,
3337 .add_to_parameter = _ccv_cnnp_rmsnorm_gated_add_to_parameter,
3338 .copy = _ccv_cnnp_rmsnorm_gated_copy,
3339};
3340
3341ccv_cnnp_model_t* ccv_cnnp_rmsnorm_gated(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)
3342{
3343 ccv_cnnp_model_rmsnorm_gated_t* const model_rmsnorm_gated = (ccv_cnnp_model_rmsnorm_gated_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_gated_t));
3344 model_rmsnorm_gated->super.isa = &ccv_cnnp_rmsnorm_gated_isa;
3345 model_rmsnorm_gated->super.input_size = 2;
3346 model_rmsnorm_gated->super.outputs = &model_rmsnorm_gated->output;
3347 model_rmsnorm_gated->super.output_size = 1;
3348 model_rmsnorm_gated->super.is_trainable = is_trainable;
3349 ccv_cnnp_model_copy_name(&model_rmsnorm_gated->super, name);
3350 model_rmsnorm_gated->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3351 model_rmsnorm_gated->scale.graph = 0;
3352 model_rmsnorm_gated->params.rmsnorm_gated.epsilon = epsilon;
3353 model_rmsnorm_gated->params.rmsnorm_gated.count = axis_count;
3354 model_rmsnorm_gated->params.rmsnorm_gated.elementwise_affine = elementwise_affine;
3355 memcpy(model_rmsnorm_gated->params.rmsnorm_gated.axis, axis, sizeof(int) * axis_count);
3356 return (ccv_cnnp_model_t*)model_rmsnorm_gated;
3357}
3358
3359static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_gated_copy(const ccv_cnnp_model_t* const super, void* const context)
3360{
3361 const ccv_cnnp_model_rmsnorm_gated_t* const self = (const ccv_cnnp_model_rmsnorm_gated_t*)super;
3362 return ccv_cnnp_rmsnorm_gated(self->params.rmsnorm_gated.epsilon, self->params.rmsnorm_gated.axis, self->params.rmsnorm_gated.count, self->params.rmsnorm_gated.elementwise_affine, self->super.is_trainable, self->super.name);
3363}
3364
3365// MARK - Batched Matrix Mul Layer
3366
3367typedef struct {
3368 ccv_cnnp_model_t super;
3369 ccv_nnc_tensor_symbol_t output;
3370 int transpose_a[2];
3371 int transpose_b[2];
3372 int flags;
3373} ccv_cnnp_model_matmul_t;
3374
3375static 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)
3376{
3377 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);
3378 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"
, 3378, __extension__ __PRETTY_FUNCTION__); }));
3379 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", 3379, __extension__ __PRETTY_FUNCTION__
); }));
3380 ccv_cnnp_model_matmul_t* const self = (ccv_cnnp_model_matmul_t*)super;
3381 ccv_nnc_tensor_param_t a_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3382 ccv_nnc_tensor_param_t b_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3383 ccv_nnc_tensor_param_t output_params;
3384 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);
3385 matmul.info.blas.flags = self->flags;
3386 ccv_nnc_hint_tensor_auto(matmul, (ccv_nnc_tensor_param_t []){
3387 a_params,
3388 b_params,
3389 }, 2, ccv_nnc_no_hint, &output_params, 1);
3390 const ccv_nnc_tensor_symbol_t matmul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3391 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");
3392 outputs[0] = matmul_output;
3393}
3394
3395static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context);
3396
3397static const ccv_cnnp_model_vtab_t ccv_cnnp_matmul_isa = {
3398 .build = _ccv_cnnp_matmul_build,
3399 .copy = _ccv_cnnp_matmul_copy,
3400};
3401
3402ccv_cnnp_model_t* ccv_cnnp_matmul(const int transpose_a[2], const int transpose_b[2], const int flags, const char* const name)
3403{
3404 ccv_cnnp_model_matmul_t* const model_matmul = (ccv_cnnp_model_matmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_matmul_t));
3405 model_matmul->super.isa = &ccv_cnnp_matmul_isa;
3406 model_matmul->super.input_size = 2;
3407 model_matmul->super.outputs = &model_matmul->output;
3408 model_matmul->super.output_size = 1;
3409 model_matmul->transpose_a[0] = transpose_a[0];
3410 model_matmul->transpose_a[1] = transpose_a[1];
3411 model_matmul->transpose_b[0] = transpose_b[0];
3412 model_matmul->transpose_b[1] = transpose_b[1];
3413 model_matmul->flags = flags;
3414 ccv_cnnp_model_copy_name(&model_matmul->super, name);
3415 return (ccv_cnnp_model_t*)model_matmul;
3416}
3417
3418static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context)
3419{
3420 const ccv_cnnp_model_matmul_t* const self = (const ccv_cnnp_model_matmul_t*)super;
3421 return ccv_cnnp_matmul(self->transpose_a, self->transpose_b, self->flags, self->super.name);
3422}
3423
3424// MARK - Dropout Layer
3425
3426typedef struct {
3427 ccv_cnnp_model_t super;
3428 ccv_nnc_tensor_symbol_t output;
3429 ccv_nnc_graph_exec_symbol_t dropout;
3430 float p;
3431 int entirety;
3432} ccv_cnnp_model_dropout_t;
3433
3434static 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)
3435{
3436 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);
3437 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"
, 3437, __extension__ __PRETTY_FUNCTION__); }));
3438 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", 3438, __extension__ __PRETTY_FUNCTION__
); }));
3439 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3440 ccv_nnc_tensor_param_t output_params[2];
3441 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
3442 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);
3443 ccv_nnc_hint_tensor_auto(dropout, (ccv_nnc_tensor_param_t []){
3444 params,
3445 }, 1, ccv_nnc_no_hint, output_params, 2);
3446 const ccv_nnc_tensor_symbol_t dropout_output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3447 const ccv_nnc_tensor_symbol_t mask = ccv_nnc_tensor_symbol_new(graph, output_params[1], "mask");
3448 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");
3449 outputs[0] = dropout_output;
3450}
3451
3452static 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)
3453{
3454 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
3455 if (self->dropout.graph)
3456 {
3457 if (is_test)
3458 // During test, the dropout is not applied. Data transfer is perfect because if these are the same tensor, it will skip.
3459 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);
3460 else
3461 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);
3462 }
3463}
3464
3465static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context);
3466
3467static const ccv_cnnp_model_vtab_t ccv_cnnp_dropout_isa = {
3468 .build = _ccv_cnnp_dropout_build,
3469 .set_is_test = _ccv_cnnp_dropout_set_is_test,
3470 .copy = _ccv_cnnp_dropout_copy,
3471};
3472
3473ccv_cnnp_model_t* ccv_cnnp_dropout(const float p, const int entirety, const char* const name)
3474{
3475 ccv_cnnp_model_dropout_t* const model_dropout = (ccv_cnnp_model_dropout_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dropout_t));
3476 model_dropout->super.isa = &ccv_cnnp_dropout_isa;
3477 model_dropout->super.input_size = 1;
3478 model_dropout->super.outputs = &model_dropout->output;
3479 model_dropout->super.output_size = 1;
3480 model_dropout->p = p;
3481 model_dropout->entirety = entirety;
3482 ccv_cnnp_model_copy_name(&model_dropout->super, name);
3483 return (ccv_cnnp_model_t*)model_dropout;
3484}
3485
3486static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context)
3487{
3488 const ccv_cnnp_model_dropout_t* const self = (const ccv_cnnp_model_dropout_t*)super;
3489 return ccv_cnnp_dropout(self->p, self->entirety, self->super.name);
3490}
3491
3492// MARK - Masked Fill Layer
3493
3494typedef struct {
3495 ccv_cnnp_model_t super;
3496 ccv_nnc_tensor_symbol_t output;
3497 float eq;
3498 float fill;
3499} ccv_cnnp_model_masked_fill_t;
3500
3501static 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)
3502{
3503 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);
3504 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"
, 3504, __extension__ __PRETTY_FUNCTION__); }));
3505 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", 3505, __extension__ __PRETTY_FUNCTION__
); }));
3506 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3507 ccv_cnnp_model_masked_fill_t* const self = (ccv_cnnp_model_masked_fill_t*)super;
3508 const ccv_nnc_tensor_symbol_t masked_fill_output = ccv_nnc_tensor_symbol_new(graph, params, 0);
3509 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");
3510 outputs[0] = masked_fill_output;
3511}
3512
3513static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context);
3514
3515static const ccv_cnnp_model_vtab_t ccv_cnnp_masked_fill_isa = {
3516 .build = _ccv_cnnp_masked_fill_build,
3517 .copy = _ccv_cnnp_masked_fill_copy,
3518};
3519
3520ccv_cnnp_model_t* ccv_cnnp_masked_fill(const float eq, const float fill, const char* const name)
3521{
3522 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));
3523 model_masked_fill->super.isa = &ccv_cnnp_masked_fill_isa;
3524 model_masked_fill->super.input_size = 2;
3525 model_masked_fill->super.outputs = &model_masked_fill->output;
3526 model_masked_fill->super.output_size = 1;
3527 model_masked_fill->eq = eq;
3528 model_masked_fill->fill = fill;
3529 ccv_cnnp_model_copy_name(&model_masked_fill->super, name);
3530 return (ccv_cnnp_model_t*)model_masked_fill;
3531}
3532
3533static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context)
3534{
3535 const ccv_cnnp_model_masked_fill_t* const self = (const ccv_cnnp_model_masked_fill_t*)super;
3536 return ccv_cnnp_masked_fill(self->eq, self->fill, self->super.name);
3537}
3538
3539// MARK - Index Select Layer
3540
3541typedef struct {
3542 ccv_cnnp_model_t super;
3543 ccv_nnc_tensor_symbol_t output;
3544} ccv_cnnp_model_index_select_t;
3545
3546static 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)
3547{
3548 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);
3549 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"
, 3549, __extension__ __PRETTY_FUNCTION__); }));
3550 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", 3550, __extension__ __PRETTY_FUNCTION__
); }));
3551 const ccv_nnc_tensor_param_t vocab_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3552 const ccv_nnc_tensor_param_t index_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3553 ccv_nnc_tensor_param_t output_params;
3554 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);
3555 ccv_nnc_hint_tensor_auto(index_select, (ccv_nnc_tensor_param_t []){
3556 vocab_params,
3557 index_params,
3558 }, 2, ccv_nnc_no_hint, &output_params, 1);
3559 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3560 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");
3561 outputs[0] = output;
3562}
3563
3564static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context);
3565
3566static const ccv_cnnp_model_vtab_t ccv_cnnp_index_select_isa = {
3567 .build = _ccv_cnnp_index_select_build,
3568 .copy = _ccv_cnnp_index_select_copy,
3569};
3570
3571ccv_cnnp_model_t* ccv_cnnp_index_select(const char* const name)
3572{
3573 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));
3574 model_index_select->super.isa = &ccv_cnnp_index_select_isa;
3575 model_index_select->super.input_size = 2;
3576 model_index_select->super.outputs = &model_index_select->output;
3577 model_index_select->super.output_size = 1;
3578 ccv_cnnp_model_copy_name(&model_index_select->super, name);
3579 return (ccv_cnnp_model_t*)model_index_select;
3580}
3581
3582static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context)
3583{
3584 ccv_cnnp_model_index_select_t* const self = (ccv_cnnp_model_index_select_t*)super;
3585 return ccv_cnnp_index_select(self->super.name);
3586}
3587
3588// MARK - Embedding Layer
3589
3590typedef struct {
3591 ccv_cnnp_model_t super;
3592 ccv_nnc_tensor_symbol_t output;
3593 ccv_nnc_tensor_symbol_t vocab;
3594 int datatype;
3595 int vocab_size;
3596 int embed_size;
3597} ccv_cnnp_model_embedding_t;
3598
3599static 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)
3600{
3601 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3602 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);
3603 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"
, 3603, __extension__ __PRETTY_FUNCTION__); }));
3604 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", 3604, __extension__ __PRETTY_FUNCTION__
); }));
3605 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3606 ccv_nnc_tensor_param_t vocab_params = params;
3607 memset(vocab_params.dim, 0, sizeof(vocab_params.dim));
3608 vocab_params.datatype = self->datatype;
3609 vocab_params.dim[0] = self->vocab_size;
3610 vocab_params.dim[1] = self->embed_size;
3611 if (!self->vocab.graph)
3612 self->vocab = ccv_nnc_tensor_symbol_new(graph, vocab_params, "vocab");
3613 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", 3613
, __extension__ __PRETTY_FUNCTION__); }));
3614 const ccv_nnc_tensor_symbol_t vocab = ccv_cnnp_model_get_symbol(super, self->vocab);
3615 ccv_nnc_tensor_param_t output_params;
3616 const ccv_nnc_cmd_t embedding = CMD_INDEX_SELECT_FORWARD()ccv_nnc_cmd(CCV_NNC_INDEX_SELECT_FORWARD, 0, ccv_nnc_cmd_auto
, 0);
3617 ccv_nnc_hint_tensor_auto(embedding, (ccv_nnc_tensor_param_t []){
3618 vocab_params,
3619 params,
3620 }, 2, ccv_nnc_no_hint, &output_params, 1);
3621 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3622 ccv_nnc_graph_exec_symbol_new(graph, embedding, TENSOR_SYMBOL_LIST(vocab, inputs[0])(const ccv_nnc_tensor_symbol_t []){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");
3623 outputs[0] = output;
3624}
3625
3626static 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)
3627{
3628 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3629 const float std = sqrtf(2) / sqrtf(self->vocab_size + self->embed_size);
3630 const float bound = sqrtf(3) * std;
3631 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);
3632}
3633
3634static 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)
3635{
3636 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3637 add_to_array(parameters, self->vocab, is_trainable);
3638}
3639
3640static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context);
3641
3642static const ccv_cnnp_model_vtab_t ccv_cnnp_embedding_isa = {
3643 .build = _ccv_cnnp_embedding_build,
3644 .init_states = _ccv_cnnp_embedding_init_states,
3645 .add_to_parameter = _ccv_cnnp_embedding_add_to_parameter,
3646 .copy = _ccv_cnnp_embedding_copy,
3647};
3648
3649ccv_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)
3650{
3651 ccv_cnnp_model_embedding_t* const model_embedding = (ccv_cnnp_model_embedding_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_embedding_t));
3652 model_embedding->super.isa = &ccv_cnnp_embedding_isa;
3653 model_embedding->super.input_size = 1;
3654 model_embedding->super.outputs = &model_embedding->output;
3655 model_embedding->super.output_size = 1;
3656 model_embedding->super.is_trainable = is_trainable;
3657 ccv_cnnp_model_copy_name(&model_embedding->super, name);
3658 model_embedding->vocab.d = CCV_NNC_NO_TENSOR_SYMBOL;
3659 model_embedding->vocab.graph = 0;
3660 assert(datatype == CCV_32F || datatype == CCV_16F || datatype == CCV_16BF || datatype == CCV_32S)((void) sizeof ((datatype == CCV_32F || datatype == CCV_16F ||
datatype == CCV_16BF || datatype == CCV_32S) ? 1 : 0), __extension__
({ if (datatype == CCV_32F || datatype == CCV_16F || datatype
== CCV_16BF || datatype == CCV_32S) ; else __assert_fail ("datatype == CCV_32F || datatype == CCV_16F || datatype == CCV_16BF || datatype == CCV_32S"
, "ccv_cnnp_model_addons.c", 3660, __extension__ __PRETTY_FUNCTION__
); }));
3661 model_embedding->datatype = datatype;
3662 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", 3662, __extension__ __PRETTY_FUNCTION__
); }));
3663 model_embedding->vocab_size = vocab_size;
3664 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", 3664, __extension__ __PRETTY_FUNCTION__
); }));
3665 model_embedding->embed_size = embed_size;
3666 return (ccv_cnnp_model_t*)model_embedding;
3667}
3668
3669static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context)
3670{
3671 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3672 return ccv_cnnp_embedding(self->datatype, self->vocab_size, self->embed_size, self->super.is_trainable, self->super.name);
3673}
3674
3675// MARK - Pool Layers
3676
3677typedef struct {
3678 ccv_cnnp_model_t super;
3679 ccv_nnc_tensor_symbol_t output;
3680 int type;
3681 float width_scale;
3682 float height_scale;
3683 int align_corners;
3684} ccv_cnnp_model_upsample_t;
3685
3686static 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)
3687{
3688 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);
3689 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"
, 3689, __extension__ __PRETTY_FUNCTION__); }));
3690 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", 3690, __extension__ __PRETTY_FUNCTION__
); }));
3691 ccv_cnnp_model_upsample_t* const self = (ccv_cnnp_model_upsample_t*)super;
3692 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3693 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);
3694 ccv_nnc_tensor_param_t output_params;
3695 ccv_nnc_hint_tensor_auto(cmd, &params, 1, ccv_nnc_no_hint, &output_params, 1);
3696 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3697 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");
3698 outputs[0] = output;
3699}
3700
3701static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context);
3702
3703static const ccv_cnnp_model_vtab_t ccv_cnnp_upsample_isa = {
3704 .build = _ccv_cnnp_upsample_build,
3705 .copy = _ccv_cnnp_upsample_copy,
3706};
3707
3708ccv_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)
3709{
3710 ccv_cnnp_model_upsample_t* const model_upsample = (ccv_cnnp_model_upsample_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_upsample_t));
3711 model_upsample->super.isa = &ccv_cnnp_upsample_isa;
3712 model_upsample->super.input_size = 1;
3713 model_upsample->super.outputs = &model_upsample->output;
3714 model_upsample->super.output_size = 1;
3715 ccv_cnnp_model_copy_name(&model_upsample->super, name);
3716 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", 3716, __extension__ __PRETTY_FUNCTION__
); }));
3717 model_upsample->type = type;
3718 model_upsample->width_scale = width_scale;
3719 model_upsample->height_scale = height_scale;
3720 model_upsample->align_corners = align_corners;
3721 return (ccv_cnnp_model_t*)model_upsample;
3722}
3723
3724static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context)
3725{
3726 const ccv_cnnp_model_upsample_t* const self = (const ccv_cnnp_model_upsample_t*)super;
3727 return ccv_cnnp_upsample(self->type, self->width_scale, self->height_scale, self->align_corners, self->super.name);
3728}
3729
3730// MARK - Reduce Sum Layer
3731
3732typedef struct {
3733 ccv_cnnp_model_t super;
3734 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3735 int count;
3736 ccv_nnc_tensor_symbol_t output;
3737} ccv_cnnp_model_reduce_sum_t;
3738
3739static 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)
3740{
3741 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);
3742 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
3743 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"
, 3743, __extension__ __PRETTY_FUNCTION__); }));
3744 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", 3744, __extension__ __PRETTY_FUNCTION__
); }));
3745 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3746 ccv_nnc_tensor_param_t output_params;
3747 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);
3748 int i;
3749 for (i = 0; i < self->count; i++)
3750 reduce_sum.info.reduce.axis[i] = self->axis[i];
3751 reduce_sum.info.reduce.count = self->count;
3752 ccv_nnc_hint_tensor_auto(reduce_sum, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3753 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3754 ccv_nnc_graph_exec_symbol_new(graph, reduce_sum, inputs, input_size, outputs, output_size, "reduce_sum");
3755}
3756
3757static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
3758
3759static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_sum_isa = {
3760 .build = _ccv_cnnp_reduce_sum_build,
3761 .copy = _ccv_cnnp_reduce_sum_copy,
3762};
3763
3764ccv_cnnp_model_t* ccv_cnnp_reduce_sum(const int* const axis, const int axis_count, const char* const name)
3765{
3766 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));
3767 model_reduce_sum->super.isa = &ccv_cnnp_reduce_sum_isa;
3768 model_reduce_sum->super.input_size = 1;
3769 model_reduce_sum->super.outputs = &model_reduce_sum->output;
3770 model_reduce_sum->super.output_size = 1;
3771 ccv_cnnp_model_copy_name(&model_reduce_sum->super, name);
3772 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", 3772, __extension__ __PRETTY_FUNCTION__
); }));
3773 int i;
3774 for (i = 0; i < axis_count; i++)
3775 model_reduce_sum->axis[i] = axis[i];
3776 model_reduce_sum->count = axis_count;
3777 return (ccv_cnnp_model_t*)model_reduce_sum;
3778}
3779
3780static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const super, void* const context)
3781{
3782 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
3783 return ccv_cnnp_reduce_sum(self->axis, self->count, self->super.name);
3784}
3785
3786// MARK - Reduce Mean Layer
3787
3788typedef struct {
3789 ccv_cnnp_model_t super;
3790 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3791 int count;
3792 ccv_nnc_tensor_symbol_t output;
3793} ccv_cnnp_model_reduce_mean_t;
3794
3795static 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)
3796{
3797 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);
3798 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3799 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"
, 3799, __extension__ __PRETTY_FUNCTION__); }));
3800 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", 3800, __extension__ __PRETTY_FUNCTION__
); }));
3801 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3802 ccv_nnc_tensor_param_t output_params;
3803 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);
3804 int i;
3805 for (i = 0; i < self->count; i++)
3806 reduce_mean.info.reduce.axis[i] = self->axis[i];
3807 reduce_mean.info.reduce.count = self->count;
3808 ccv_nnc_hint_tensor_auto(reduce_mean, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3809 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3810 ccv_nnc_graph_exec_symbol_new(graph, reduce_mean, inputs, input_size, outputs, output_size, "reduce_mean");
3811}
3812
3813static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const self, void* const context);
3814
3815static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_mean_isa = {
3816 .build = _ccv_cnnp_reduce_mean_build,
3817 .copy = _ccv_cnnp_reduce_mean_copy,
3818};
3819
3820ccv_cnnp_model_t* ccv_cnnp_reduce_mean(const int* const axis, const int axis_count, const char* const name)
3821{
3822 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));
3823 model_reduce_mean->super.isa = &ccv_cnnp_reduce_mean_isa;
3824 model_reduce_mean->super.input_size = 1;
3825 model_reduce_mean->super.outputs = &model_reduce_mean->output;
3826 model_reduce_mean->super.output_size = 1;
3827 ccv_cnnp_model_copy_name(&model_reduce_mean->super, name);
3828 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", 3828, __extension__ __PRETTY_FUNCTION__
); }));
3829 int i;
3830 for (i = 0; i < axis_count; i++)
3831 model_reduce_mean->axis[i] = axis[i];
3832 model_reduce_mean->count = axis_count;
3833 return (ccv_cnnp_model_t*)model_reduce_mean;
3834}
3835
3836static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const super, void* const context)
3837{
3838 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3839 return ccv_cnnp_reduce_mean(self->axis, self->count, self->super.name);
3840}
3841
3842// MARK - Reduce Max Layer
3843
3844typedef struct {
3845 ccv_cnnp_model_t super;
3846 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3847 int count;
3848 ccv_nnc_tensor_symbol_t output;
3849} ccv_cnnp_model_reduce_max_t;
3850
3851static 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)
3852{
3853 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);
3854 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3855 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"
, 3855, __extension__ __PRETTY_FUNCTION__); }));
3856 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", 3856, __extension__ __PRETTY_FUNCTION__
); }));
3857 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3858 ccv_nnc_tensor_param_t output_params;
3859 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);
3860 int i;
3861 for (i = 0; i < self->count; i++)
3862 reduce_max.info.reduce.axis[i] = self->axis[i];
3863 reduce_max.info.reduce.count = self->count;
3864 ccv_nnc_hint_tensor_auto(reduce_max, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3865 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3866 ccv_nnc_graph_exec_symbol_new(graph, reduce_max, inputs, input_size, outputs, output_size, "reduce_max");
3867}
3868
3869static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const self, void* const context);
3870
3871static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_max_isa = {
3872 .build = _ccv_cnnp_reduce_max_build,
3873 .copy = _ccv_cnnp_reduce_max_copy,
3874};
3875
3876ccv_cnnp_model_t* ccv_cnnp_reduce_max(const int* const axis, const int axis_count, const char* const name)
3877{
3878 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));
3879 model_reduce_max->super.isa = &ccv_cnnp_reduce_max_isa;
3880 model_reduce_max->super.input_size = 1;
3881 model_reduce_max->super.outputs = &model_reduce_max->output;
3882 model_reduce_max->super.output_size = 1;
3883 ccv_cnnp_model_copy_name(&model_reduce_max->super, name);
3884 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", 3884, __extension__ __PRETTY_FUNCTION__
); }));
3885 int i;
3886 for (i = 0; i < axis_count; i++)
3887 model_reduce_max->axis[i] = axis[i];
3888 model_reduce_max->count = axis_count;
3889 return (ccv_cnnp_model_t*)model_reduce_max;
3890}
3891
3892static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const super, void* const context)
3893{
3894 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
3895 return ccv_cnnp_reduce_max(self->axis, self->count, self->super.name);
3896}
3897
3898// MARK - Reduce Min Layer
3899
3900typedef struct {
3901 ccv_cnnp_model_t super;
3902 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3903 int count;
3904 ccv_nnc_tensor_symbol_t output;
3905} ccv_cnnp_model_reduce_min_t;
3906
3907static 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)
3908{
3909 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);
3910 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3911 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"
, 3911, __extension__ __PRETTY_FUNCTION__); }));
3912 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", 3912, __extension__ __PRETTY_FUNCTION__
); }));
3913 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3914 ccv_nnc_tensor_param_t output_params;
3915 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);
3916 int i;
3917 for (i = 0; i < self->count; i++)
3918 reduce_min.info.reduce.axis[i] = self->axis[i];
3919 reduce_min.info.reduce.count = self->count;
3920 ccv_nnc_hint_tensor_auto(reduce_min, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3921 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3922 ccv_nnc_graph_exec_symbol_new(graph, reduce_min, inputs, input_size, outputs, output_size, "reduce_min");
3923}
3924
3925static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const self, void* const context);
3926
3927static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_min_isa = {
3928 .build = _ccv_cnnp_reduce_min_build,
3929 .copy = _ccv_cnnp_reduce_min_copy,
3930};
3931
3932ccv_cnnp_model_t* ccv_cnnp_reduce_min(const int* const axis, const int axis_count, const char* const name)
3933{
3934 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));
3935 model_reduce_min->super.isa = &ccv_cnnp_reduce_min_isa;
3936 model_reduce_min->super.input_size = 1;
3937 model_reduce_min->super.outputs = &model_reduce_min->output;
3938 model_reduce_min->super.output_size = 1;
3939 ccv_cnnp_model_copy_name(&model_reduce_min->super, name);
3940 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", 3940, __extension__ __PRETTY_FUNCTION__
); }));
3941 int i;
3942 for (i = 0; i < axis_count; i++)
3943 model_reduce_min->axis[i] = axis[i];
3944 model_reduce_min->count = axis_count;
3945 return (ccv_cnnp_model_t*)model_reduce_min;
3946}
3947
3948static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const super, void* const context)
3949{
3950 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
3951 return ccv_cnnp_reduce_min(self->axis, self->count, self->super.name);
3952}
3953
3954// MARK - Reduce Norm2 Layer
3955
3956typedef struct {
3957 ccv_cnnp_model_t super;
3958 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3959 int count;
3960 ccv_nnc_tensor_symbol_t output;
3961} ccv_cnnp_model_reduce_norm2_t;
3962
3963static 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)
3964{
3965 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
3966 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);
3967 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"
, 3967, __extension__ __PRETTY_FUNCTION__); }));
3968 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", 3968, __extension__ __PRETTY_FUNCTION__
); }));
3969 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3970 ccv_nnc_tensor_param_t output_params;
3971 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);
3972 int i;
3973 for (i = 0; i < self->count; i++)
3974 reduce_norm2.info.reduce.axis[i] = self->axis[i];
3975 reduce_norm2.info.reduce.count = self->count;
3976 ccv_nnc_hint_tensor_auto(reduce_norm2, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3977 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3978 ccv_nnc_graph_exec_symbol_new(graph, reduce_norm2, inputs, input_size, outputs, output_size, "reduce_norm2");
3979}
3980
3981static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const self, void* const context);
3982
3983static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_norm2_isa = {
3984 .build = _ccv_cnnp_reduce_norm2_build,
3985 .copy = _ccv_cnnp_reduce_norm2_copy,
3986};
3987
3988ccv_cnnp_model_t* ccv_cnnp_reduce_norm2(const int* const axis, const int axis_count, const char* const name)
3989{
3990 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));
3991 model_reduce_norm2->super.isa = &ccv_cnnp_reduce_norm2_isa;
3992 model_reduce_norm2->super.input_size = 1;
3993 model_reduce_norm2->super.outputs = &model_reduce_norm2->output;
3994 model_reduce_norm2->super.output_size = 1;
3995 ccv_cnnp_model_copy_name(&model_reduce_norm2->super, name);
3996 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", 3996, __extension__ __PRETTY_FUNCTION__
); }));
3997 int i;
3998 for (i = 0; i < axis_count; i++)
3999 model_reduce_norm2->axis[i] = axis[i];
4000 model_reduce_norm2->count = axis_count;
4001 return (ccv_cnnp_model_t*)model_reduce_norm2;
4002}
4003
4004static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const super, void* const context)
4005{
4006 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
4007 return ccv_cnnp_reduce_norm2(self->axis, self->count, self->super.name);
4008}
4009
4010// MARK - Argmax Layer
4011
4012typedef struct {
4013 ccv_cnnp_model_t super;
4014 int axis;
4015 ccv_nnc_tensor_symbol_t output;
4016} ccv_cnnp_model_argmax_t;
4017
4018static 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)
4019{
4020 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
4021 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);
4022 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"
, 4022, __extension__ __PRETTY_FUNCTION__); }));
4023 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", 4023, __extension__ __PRETTY_FUNCTION__
); }));
4024 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4025 ccv_nnc_tensor_param_t output_params;
4026 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);
4027 argmax.info.reduce.axis[0] = self->axis;
4028 argmax.info.reduce.count = 1;
4029 ccv_nnc_hint_tensor_auto(argmax, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4030 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4031 ccv_nnc_graph_exec_symbol_new(graph, argmax, inputs, input_size, outputs, output_size, "argmax");
4032}
4033
4034static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const self, void* const context);
4035
4036static const ccv_cnnp_model_vtab_t ccv_cnnp_argmax_isa = {
4037 .build = _ccv_cnnp_argmax_build,
4038 .copy = _ccv_cnnp_argmax_copy,
4039};
4040
4041ccv_cnnp_model_t* ccv_cnnp_argmax(const int axis, const char* const name)
4042{
4043 ccv_cnnp_model_argmax_t* const model_argmax = (ccv_cnnp_model_argmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmax_t));
4044 model_argmax->super.isa = &ccv_cnnp_argmax_isa;
4045 model_argmax->super.input_size = 1;
4046 model_argmax->super.outputs = &model_argmax->output;
4047 model_argmax->super.output_size = 1;
4048 ccv_cnnp_model_copy_name(&model_argmax->super, name);
4049 model_argmax->axis = axis;
4050 return (ccv_cnnp_model_t*)model_argmax;
4051}
4052
4053static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const super, void* const context)
4054{
4055 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
4056 return ccv_cnnp_argmax(self->axis, self->super.name);
4057}
4058
4059// MARK - Argmin Layer
4060
4061typedef struct {
4062 ccv_cnnp_model_t super;
4063 int axis;
4064 ccv_nnc_tensor_symbol_t output;
4065} ccv_cnnp_model_argmin_t;
4066
4067static 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)
4068{
4069 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
4070 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);
4071 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"
, 4071, __extension__ __PRETTY_FUNCTION__); }));
4072 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", 4072, __extension__ __PRETTY_FUNCTION__
); }));
4073 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4074 ccv_nnc_tensor_param_t output_params;
4075 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);
4076 argmin.info.reduce.axis[0] = self->axis;
4077 argmin.info.reduce.count = 1;
4078 ccv_nnc_hint_tensor_auto(argmin, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4079 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4080 ccv_nnc_graph_exec_symbol_new(graph, argmin, inputs, input_size, outputs, output_size, "argmin");
4081}
4082
4083static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const self, void* const context);
4084
4085static const ccv_cnnp_model_vtab_t ccv_cnnp_argmin_isa = {
4086 .build = _ccv_cnnp_argmin_build,
4087 .copy = _ccv_cnnp_argmin_copy,
4088};
4089
4090ccv_cnnp_model_t* ccv_cnnp_argmin(const int axis, const char* const name)
4091{
4092 ccv_cnnp_model_argmin_t* const model_argmin = (ccv_cnnp_model_argmin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmin_t));
4093 model_argmin->super.isa = &ccv_cnnp_argmin_isa;
4094 model_argmin->super.input_size = 1;
4095 model_argmin->super.outputs = &model_argmin->output;
4096 model_argmin->super.output_size = 1;
4097 ccv_cnnp_model_copy_name(&model_argmin->super, name);
4098 model_argmin->axis = axis;
4099 return (ccv_cnnp_model_t*)model_argmin;
4100}
4101
4102static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const super, void* const context)
4103{
4104 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
4105 return ccv_cnnp_argmin(self->axis, self->super.name);
4106}
4107
4108// MARK - Min Layer
4109
4110typedef struct {
4111 ccv_cnnp_model_t super;
4112 ccv_nnc_tensor_symbol_t output;
4113} ccv_cnnp_model_min_t;
4114
4115static 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)
4116{
4117 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);
4118 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"
, 4118, __extension__ __PRETTY_FUNCTION__); }));
4119 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", 4119, __extension__ __PRETTY_FUNCTION__
); }));
4120 ccv_nnc_tensor_param_t input_params[2];
4121 int i;
4122 for (i = 0; i < 2; i++)
4123 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
4124 ccv_nnc_tensor_param_t output_params;
4125 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);
4126 ccv_nnc_hint_tensor_auto(min, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
4127 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4128 ccv_nnc_graph_exec_symbol_new(graph, min, inputs, input_size, outputs, output_size, "min");
4129}
4130
4131static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const self, void* const context);
4132
4133static const ccv_cnnp_model_vtab_t ccv_cnnp_min_isa = {
4134 .build = _ccv_cnnp_min_build,
4135 .copy = _ccv_cnnp_min_copy,
4136};
4137
4138ccv_cnnp_model_t* ccv_cnnp_min(const char* const name)
4139{
4140 ccv_cnnp_model_min_t* const model_min = (ccv_cnnp_model_min_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_min_t));
4141 model_min->super.isa = &ccv_cnnp_min_isa;
4142 model_min->super.input_size = 2;
4143 model_min->super.outputs = &model_min->output;
4144 model_min->super.output_size = 1;
4145 ccv_cnnp_model_copy_name(&model_min->super, name);
4146 return (ccv_cnnp_model_t*)model_min;
4147}
4148
4149static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const super, void* const context)
4150{
4151 const ccv_cnnp_model_min_t* const self = (const ccv_cnnp_model_min_t*)super;
4152 return ccv_cnnp_min(self->super.name);
4153}
4154
4155// MARK - Max Layer
4156
4157typedef struct {
4158 ccv_cnnp_model_t super;
4159 ccv_nnc_tensor_symbol_t output;
4160} ccv_cnnp_model_max_t;
4161
4162static 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)
4163{
4164 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);
4165 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"
, 4165, __extension__ __PRETTY_FUNCTION__); }));
4166 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", 4166, __extension__ __PRETTY_FUNCTION__
); }));
4167 ccv_nnc_tensor_param_t input_params[2];
4168 int i;
4169 for (i = 0; i < 2; i++)
4170 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
4171 ccv_nnc_tensor_param_t output_params;
4172 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);
4173 ccv_nnc_hint_tensor_auto(max, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
4174 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4175 ccv_nnc_graph_exec_symbol_new(graph, max, inputs, input_size, outputs, output_size, "max");
4176}
4177
4178static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const self, void* const context);
4179
4180static const ccv_cnnp_model_vtab_t ccv_cnnp_max_isa = {
4181 .build = _ccv_cnnp_max_build,
4182 .copy = _ccv_cnnp_max_copy,
4183};
4184
4185ccv_cnnp_model_t* ccv_cnnp_max(const char* const name)
4186{
4187 ccv_cnnp_model_max_t* const model_max = (ccv_cnnp_model_max_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_max_t));
4188 model_max->super.isa = &ccv_cnnp_max_isa;
4189 model_max->super.input_size = 2;
4190 model_max->super.outputs = &model_max->output;
4191 model_max->super.output_size = 1;
4192 ccv_cnnp_model_copy_name(&model_max->super, name);
4193 return (ccv_cnnp_model_t*)model_max;
4194}
4195
4196static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const super, void* const context)
4197{
4198 const ccv_cnnp_model_max_t* const self = (const ccv_cnnp_model_max_t*)super;
4199 return ccv_cnnp_max(self->super.name);
4200}
4201
4202// MARK - LSTM Layer
4203
4204typedef struct {
4205 ccv_cnnp_model_t super;
4206 int masked;
4207 ccv_nnc_tensor_symbol_t output;
4208 ccv_nnc_tensor_symbol_t weights;
4209 ccv_nnc_tensor_symbol_t reserves;
4210 ccv_nnc_cmd_param_t params;
4211 ccv_nnc_graph_exec_symbol_t lstm;
4212} ccv_cnnp_model_lstm_t;
4213
4214static int _ccv_cnnp_lstm_weight_dim(int bidirectional, int num_layers, int input_size, int hidden_size, int proj_size, int bias)
4215{
4216 const int D = !!bidirectional + 1;
4217 if (hidden_size == proj_size)
4218 return (num_layers * (bias ? 8 : 0) + (num_layers - 1) * (hidden_size * 4 * D + hidden_size * 4) + input_size * 4 + hidden_size * 4) * D;
4219 else
4220 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;
4221}
4222
4223static 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)
4224{
4225 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4226 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);
4227 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", 4227, __extension__ __PRETTY_FUNCTION__
); }));
4228 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", 4228, __extension__ __PRETTY_FUNCTION__
); }));
4229 const int proj_size = self->params.rnn.proj_size == 0 ? self->params.rnn.hidden_size : self->params.rnn.proj_size;
4230 ccv_nnc_tensor_param_t input_params[5];
4231 input_params[0]= ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4232 if (input_size == 2)
4233 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
4234 input_params[4] = input_params[0];
4235 memset(input_params[4].dim, 0, sizeof(input_params[4].dim));
4236 const int x_nd = ccv_nnc_tensor_nd(input_params[0].dim);
4237 const int feature_count = input_params[0].dim[x_nd - 1];
4238 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);
4239 input_params[4].dim[1] = self->params.rnn.hidden_size;
4240 const ccv_nnc_cmd_t lstm = ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0);
4241 ccv_nnc_tensor_param_t output_params[4];
4242 ccv_nnc_hint_tensor_auto(lstm, input_params, 5, ccv_nnc_no_hint, output_params, 4);
4243 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4244 if (!self->weights.graph)
4245 self->weights = ccv_nnc_tensor_symbol_new(graph, input_params[4], "weights");
4246 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"
, 4246, __extension__ __PRETTY_FUNCTION__); }));
4247 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
4248 if (!self->reserves.graph)
4249 self->reserves = ccv_nnc_tensor_symbol_new(graph, output_params[3], "reserves");
4250 assert(self->reserves.graph == graph)((void) sizeof ((self->reserves.graph == graph) ? 1 : 0), __extension__
({ if (self->reserves.graph == graph) ; else __assert_fail
("self->reserves.graph == graph", "ccv_cnnp_model_addons.c"
, 4250, __extension__ __PRETTY_FUNCTION__); }));
4251 const ccv_nnc_tensor_symbol_t reserves = ccv_cnnp_model_get_symbol(super, self->reserves);
4252 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
};
4253 self->lstm = ccv_nnc_graph_exec_symbol_new(graph, lstm, TENSOR_SYMBOL_LIST(inputs[0], mask, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, 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}, 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, 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}, 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");
4254}
4255
4256static 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)
4257{
4258 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4259 if (self->weights.graph)
4260 {
4261 const float stdv = 1.0 / sqrt(self->params.rnn.hidden_size);
4262 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);
4263 }
4264}
4265
4266static 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)
4267{
4268 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4269 if (self->weights.graph)
4270 add_to_array(parameters, self->weights, is_trainable);
4271}
4272
4273static 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)
4274{
4275 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4276 if (self->lstm.graph)
4277 {
4278 self->params.rnn.is_test = is_test;
4279 updater(context, self->lstm, ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
4280 }
4281}
4282
4283static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const self, void* const context);
4284
4285static const ccv_cnnp_model_vtab_t ccv_cnnp_lstm_isa = {
4286 .build = _ccv_cnnp_lstm_build,
4287 .init_states = _ccv_cnnp_lstm_init_states,
4288 .add_to_parameter = _ccv_cnnp_lstm_add_to_parameter,
4289 .copy = _ccv_cnnp_lstm_copy,
4290 .set_is_test = _ccv_cnnp_lstm_set_is_test,
4291};
4292
4293ccv_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)
4294{
4295 ccv_cnnp_model_lstm_t* const model_lstm = (ccv_cnnp_model_lstm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_lstm_t));
4296 model_lstm->super.isa = &ccv_cnnp_lstm_isa;
4297 model_lstm->super.input_size = masked ? 2 : 1;
4298 model_lstm->super.outputs = &model_lstm->output;
4299 model_lstm->super.output_size = 1;
4300 model_lstm->super.is_trainable = is_trainable;
4301 ccv_cnnp_model_copy_name(&model_lstm->super, name);
4302 model_lstm->masked = masked;
4303 model_lstm->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4304 model_lstm->weights.graph = 0;
4305 model_lstm->params.rnn.hidden_size = hidden_size;
4306 model_lstm->params.rnn.proj_size = proj_size;
4307 model_lstm->params.rnn.num_layers = num_layers;
4308 model_lstm->params.rnn.bias = bias;
4309 model_lstm->params.rnn.batch_first = batch_first;
4310 model_lstm->params.rnn.bidirectional = bidirectional;
4311 model_lstm->params.rnn.dropout = dropout;
4312 return (ccv_cnnp_model_t*)model_lstm;
4313}
4314
4315static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const super, void* const context)
4316{
4317 const ccv_cnnp_model_lstm_t* const self = (const ccv_cnnp_model_lstm_t*)super;
4318 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);
4319}
4320
4321/// MARK - Datatype conversion layer.
4322
4323typedef struct {
4324 ccv_cnnp_model_t super;
4325 ccv_nnc_tensor_symbol_t output;
4326 int datatype;
4327 int ref_to_last;
4328} ccv_cnnp_model_datatype_conversion_t;
4329
4330static 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)
4331{
4332 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
4333 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);
4334 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4335 if (self->ref_to_last)
4336 {
4337 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", 4337, __extension__ __PRETTY_FUNCTION__
); }));
4338 const ccv_nnc_tensor_param_t last_params = ccv_nnc_tensor_symbol_params(graph, inputs[input_size - 1]);
4339 params.datatype = last_params.datatype;
4340 } else
4341 params.datatype = self->datatype;
4342 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", 4342, __extension__ __PRETTY_FUNCTION__
); }));
4343 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4344 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);
4345}
4346
4347static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const self, void* const context);
4348
4349static const ccv_cnnp_model_vtab_t ccv_cnnp_datatype_conversion_isa = {
4350 .build = _ccv_cnnp_datatype_conversion_build,
4351 .copy = _ccv_cnnp_datatype_conversion_copy,
4352};
4353
4354ccv_cnnp_model_t* ccv_cnnp_datatype_conversion(const int datatype, const int ref_to_last, const char* const name)
4355{
4356 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));
4357 model_datatype_conversion->super.isa = &ccv_cnnp_datatype_conversion_isa;
4358 model_datatype_conversion->super.input_size = 0;
4359 model_datatype_conversion->super.outputs = &model_datatype_conversion->output;
4360 model_datatype_conversion->super.output_size = 1;
4361 model_datatype_conversion->datatype = datatype;
4362 model_datatype_conversion->ref_to_last = ref_to_last;
4363 ccv_cnnp_model_copy_name(&model_datatype_conversion->super, name);
4364 return (ccv_cnnp_model_t*)model_datatype_conversion;
4365}
4366
4367static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const super, void* const context)
4368{
4369 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
4370 return ccv_cnnp_datatype_conversion(self->datatype, self->ref_to_last, self->super.name);
4371}
4372
4373/// MARK - Clamp layer.
4374
4375typedef struct {
4376 ccv_cnnp_model_t super;
4377 ccv_nnc_tensor_symbol_t output;
4378 float min;
4379 float max;
4380} ccv_cnnp_model_clamp_t;
4381
4382static 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)
4383{
4384 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
4385 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);
4386 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4387 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", 4387, __extension__ __PRETTY_FUNCTION__
); }));
4388 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4389 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);
4390}
4391
4392static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const self, void* const context);
4393
4394static const ccv_cnnp_model_vtab_t ccv_cnnp_clamp_isa = {
4395 .build = _ccv_cnnp_clamp_build,
4396 .copy = _ccv_cnnp_clamp_copy,
4397};
4398
4399ccv_cnnp_model_t* ccv_cnnp_clamp(const float min, const float max, const char* const name)
4400{
4401 ccv_cnnp_model_clamp_t* const model_clamp = (ccv_cnnp_model_clamp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_clamp_t));
4402 model_clamp->super.isa = &ccv_cnnp_clamp_isa;
4403 model_clamp->super.input_size = 0;
4404 model_clamp->super.outputs = &model_clamp->output;
4405 model_clamp->super.output_size = 1;
4406 model_clamp->min = min;
4407 model_clamp->max = max;
4408 ccv_cnnp_model_copy_name(&model_clamp->super, name);
4409 return (ccv_cnnp_model_t*)model_clamp;
4410}
4411
4412static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const super, void* const context)
4413{
4414 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
4415 return ccv_cnnp_clamp(self->min, self->max, self->super.name);
4416}
4417
4418// MARK - Parameter Layer
4419
4420typedef struct {
4421 ccv_cnnp_model_t super;
4422 float init_bound;
4423 ccv_nnc_tensor_symbol_t weights;
4424 ccv_nnc_tensor_param_t weights_params;
4425 ccv_nnc_tensor_symbol_t output;
4426} ccv_cnnp_model_parameter_t;
4427
4428static 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)
4429{
4430 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);
4431 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", 4431, __extension__ __PRETTY_FUNCTION__
); }));
4432 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4433 if (!self->weights.graph)
4434 self->weights = ccv_nnc_tensor_symbol_new(graph, self->weights_params, "weights");
4435 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"
, 4435, __extension__ __PRETTY_FUNCTION__); }));
4436 outputs[0] = ccv_cnnp_model_get_symbol(super, self->weights);
4437}
4438
4439static 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)
4440{
4441 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4442 if (self->init_bound > 0)
4443 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);
4444 else
4445 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);
4446}
4447
4448static 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)
4449{
4450 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4451 add_to_array(parameters, self->weights, is_trainable);
4452}
4453
4454static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context);
4455
4456static const ccv_cnnp_model_vtab_t ccv_cnnp_parameter_isa = {
4457 .build = _ccv_cnnp_parameter_build,
4458 .init_states = _ccv_cnnp_parameter_init_states,
4459 .add_to_parameter = _ccv_cnnp_parameter_add_to_parameter,
4460 .copy = _ccv_cnnp_parameter_copy,
4461};
4462
4463ccv_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)
4464{
4465 ccv_cnnp_model_parameter_t* const model_parameter = (ccv_cnnp_model_parameter_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_parameter_t));
4466 model_parameter->super.isa = &ccv_cnnp_parameter_isa;
4467 model_parameter->super.input_size = 0;
4468 model_parameter->super.outputs = &model_parameter->output;
4469 model_parameter->super.output_size = 1;
4470 model_parameter->super.is_trainable = is_trainable;
4471 ccv_cnnp_model_copy_name(&model_parameter->super, name);
4472 model_parameter->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4473 model_parameter->weights.graph = 0;
4474 model_parameter->weights_params = params;
4475 return (ccv_cnnp_model_t*)model_parameter;
4476}
4477
4478static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context)
4479{
4480 const ccv_cnnp_model_parameter_t* const self = (const ccv_cnnp_model_parameter_t*)super;
4481 return ccv_cnnp_parameter(self->weights_params, self->init_bound, self->super.is_trainable, self->super.name);
4482}
4483
4484// MARK - Scalar Layer
4485
4486typedef struct {
4487 ccv_cnnp_model_t super;
4488 int type;
4489 int format;
4490 int datatype;
4491 float value;
4492 ccv_nnc_tensor_symbol_t output;
4493} ccv_cnnp_model_scalar_t;
4494
4495static 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)
4496{
4497 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);
4498 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", 4498, __extension__ __PRETTY_FUNCTION__
); }));
4499 ccv_cnnp_model_scalar_t* const self = (ccv_cnnp_model_scalar_t*)super;
4500 ccv_nnc_tensor_param_t params = {
4501 .type = self->type,
4502 .format = self->format,
4503 .datatype = self->datatype,
4504 .dim = {
4505 1
4506 }
4507 };
4508 if (input_size > 0)
4509 {
4510 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4511 params.type = input_params.type;
4512 params.format = input_params.format;
4513 params.datatype = input_params.datatype;
4514 }
4515 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4516 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);
4517}
4518
4519static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context);
4520
4521static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_isa = {
4522 .build = _ccv_cnnp_scalar_build,
4523 .copy = _ccv_cnnp_scalar_copy,
4524};
4525
4526ccv_cnnp_model_t* ccv_cnnp_scalar(const int type, const int format, const int datatype, const float value, const char* const name)
4527{
4528 ccv_cnnp_model_scalar_t* const model_scalar = (ccv_cnnp_model_scalar_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scalar_t));
4529 model_scalar->super.isa = &ccv_cnnp_scalar_isa;
4530 model_scalar->super.input_size = 0;
4531 model_scalar->super.outputs = &model_scalar->output;
4532 model_scalar->super.output_size = 1;
4533 ccv_cnnp_model_copy_name(&model_scalar->super, name);
4534 model_scalar->type = type;
4535 model_scalar->format = format;
4536 model_scalar->datatype = datatype;
4537 model_scalar->value = value;
4538 return (ccv_cnnp_model_t*)model_scalar;
4539}
4540
4541static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context)
4542{
4543 const ccv_cnnp_model_scalar_t* const self = (const ccv_cnnp_model_scalar_t*)super;
4544 return ccv_cnnp_scalar(self->type, self->format, self->datatype, self->value, self->super.name);
4545}
4546
4547// MARK - Variable Layer
4548
4549typedef struct {
4550 ccv_cnnp_model_t super;
4551 ccv_nnc_tensor_param_t params;
4552 ccv_nnc_tensor_symbol_t output;
4553} ccv_cnnp_model_variable_t;
4554
4555static 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)
4556{
4557 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);
4558 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"
, 4558, __extension__ __PRETTY_FUNCTION__); }));
4559 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", 4559, __extension__ __PRETTY_FUNCTION__
); }));
4560 ccv_cnnp_model_variable_t* const self = (ccv_cnnp_model_variable_t*)super;
4561 outputs[0] = ccv_nnc_tensor_symbol_new(graph, self->params, 0);
4562}
4563
4564static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context);
4565
4566static const ccv_cnnp_model_vtab_t ccv_cnnp_variable_isa = {
4567 .build = _ccv_cnnp_variable_build,
4568 .copy = _ccv_cnnp_variable_copy,
4569};
4570
4571ccv_cnnp_model_t* ccv_cnnp_variable(const ccv_nnc_tensor_param_t params, const char* const name)
4572{
4573 ccv_cnnp_model_variable_t* const model_variable = (ccv_cnnp_model_variable_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_variable_t));
4574 model_variable->super.isa = &ccv_cnnp_variable_isa;
4575 model_variable->super.input_size = 0;
4576 model_variable->super.outputs = &model_variable->output;
4577 model_variable->super.output_size = 1;
4578 ccv_cnnp_model_copy_name(&model_variable->super, name);
4579 model_variable->params = params;
4580 return (ccv_cnnp_model_t*)model_variable;
4581}
4582
4583static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context)
4584{
4585 const ccv_cnnp_model_variable_t* const self = (const ccv_cnnp_model_variable_t*)super;
4586 return ccv_cnnp_variable(self->params, self->super.name);
4587}
4588
4589// MARK - Set Layer
4590
4591typedef struct {
4592 ccv_cnnp_model_t super;
4593 float value;
4594 ccv_nnc_tensor_symbol_t output;
4595} ccv_cnnp_model_set_t;
4596
4597static void _ccv_cnnp_set_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)
4598{
4599 PRINT(CCV_CLI_VERBOSE, "[cnnp_set_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_set_build] -\n"); fflush(stdout); } } while (
0);
4600 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"
, 4600, __extension__ __PRETTY_FUNCTION__); }));
4601 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", 4601, __extension__ __PRETTY_FUNCTION__
); }));
4602 ccv_cnnp_model_set_t* const self = (ccv_cnnp_model_set_t*)super;
4603 outputs[0] = inputs[0];
4604 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, "set");
4605}
4606
4607static ccv_cnnp_model_t* _ccv_cnnp_set_copy(const ccv_cnnp_model_t* const super, void* const context);
4608
4609static const ccv_cnnp_model_vtab_t ccv_cnnp_set_isa = {
4610 .build = _ccv_cnnp_set_build,
4611 .copy = _ccv_cnnp_set_copy,
4612};
4613
4614ccv_cnnp_model_t* ccv_cnnp_set(const float value, const char* const name)
4615{
4616 ccv_cnnp_model_set_t* const model_set = (ccv_cnnp_model_set_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_set_t));
4617 model_set->super.isa = &ccv_cnnp_set_isa;
4618 model_set->super.input_size = 1;
4619 model_set->super.outputs = &model_set->output;
4620 model_set->super.output_size = 1;
4621 ccv_cnnp_model_copy_name(&model_set->super, name);
4622 model_set->value = value;
4623 return (ccv_cnnp_model_t*)model_set;
4624}
4625
4626static ccv_cnnp_model_t* _ccv_cnnp_set_copy(const ccv_cnnp_model_t* const super, void* const context)
4627{
4628 const ccv_cnnp_model_set_t* const self = (const ccv_cnnp_model_set_t*)super;
4629 return ccv_cnnp_set(self->value, self->super.name);
4630}
4631
4632// MARK - Send Layer
4633
4634typedef struct {
4635 ccv_cnnp_model_t super;
4636 int device_id;
4637 ccv_nnc_tensor_symbol_t output;
4638} ccv_cnnp_model_send_t;
4639
4640static void _ccv_cnnp_send_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)
4641{
4642 ccv_cnnp_model_send_t* const self = (ccv_cnnp_model_send_t*)super;
4643 PRINT(CCV_CLI_VERBOSE, "[cnnp_send_build] - device_id: %d\n", self->device_id)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_send_build] - device_id: %d\n", self->device_id
); fflush(stdout); } } while (0);
4644 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"
, 4644, __extension__ __PRETTY_FUNCTION__); }));
4645 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", 4645, __extension__ __PRETTY_FUNCTION__
); }));
4646 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4647 params.type = (params.type & ~0x3) | CCV_TENSOR_GPU_MEMORY;
4648 CCV_TENSOR_SET_DEVICE_ID(params.type, self->device_id)(params.type) = (((params.type) & ~0xfff00) | (((self->
device_id) & 0xfff) << 8));
4649 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4650 ccv_nnc_graph_exec_symbol_new(graph, CMD_DATA_TRANSFER_FORWARD()ccv_nnc_cmd(CCV_NNC_DATA_TRANSFER_FORWARD, 0, ccv_nnc_cmd_auto
, 0), inputs, 1, outputs, 1, "send");
4651}
4652
4653static ccv_cnnp_model_t* _ccv_cnnp_send_copy(const ccv_cnnp_model_t* const super, void* const context);
4654
4655static const ccv_cnnp_model_vtab_t ccv_cnnp_send_isa = {
4656 .build = _ccv_cnnp_send_build,
4657 .copy = _ccv_cnnp_send_copy,
4658};
4659
4660ccv_cnnp_model_t* ccv_cnnp_send(const int device_id, const char* const name)
4661{
4662 assert(device_id >= 0)((void) sizeof ((device_id >= 0) ? 1 : 0), __extension__ (
{ if (device_id >= 0) ; else __assert_fail ("device_id >= 0"
, "ccv_cnnp_model_addons.c", 4662, __extension__ __PRETTY_FUNCTION__
); }));
4663 ccv_cnnp_model_send_t* const model_send = (ccv_cnnp_model_send_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_send_t));
4664 model_send->super.isa = &ccv_cnnp_send_isa;
4665 model_send->super.input_size = 1;
4666 model_send->super.outputs = &model_send->output;
4667 model_send->super.output_size = 1;
4668 ccv_cnnp_model_copy_name(&model_send->super, name);
4669 model_send->device_id = device_id;
4670 return (ccv_cnnp_model_t*)model_send;
4671}
4672
4673static ccv_cnnp_model_t* _ccv_cnnp_send_copy(const ccv_cnnp_model_t* const super, void* const context)
4674{
4675 const ccv_cnnp_model_send_t* const self = (const ccv_cnnp_model_send_t*)super;
4676 return ccv_cnnp_send(self->device_id, self->super.name);
4677}
4678
4679// MARK - Move Layer
4680
4681typedef struct {
4682 ccv_cnnp_model_t super;
4683 ccv_nnc_tensor_symbol_t output;
4684} ccv_cnnp_model_move_t;
4685
4686static 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)
4687{
4688 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);
4689 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"
, 4689, __extension__ __PRETTY_FUNCTION__); }));
4690 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", 4690, __extension__ __PRETTY_FUNCTION__
); }));
4691 outputs[0] = inputs[1];
4692 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");
4693}
4694
4695static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context);
4696
4697static const ccv_cnnp_model_vtab_t ccv_cnnp_move_isa = {
4698 .build = _ccv_cnnp_move_build,
4699 .copy = _ccv_cnnp_move_copy,
4700};
4701
4702ccv_cnnp_model_t* ccv_cnnp_move(const char* const name)
4703{
4704 ccv_cnnp_model_move_t* const model_move = (ccv_cnnp_model_move_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_move_t));
4705 model_move->super.isa = &ccv_cnnp_move_isa;
4706 model_move->super.input_size = 2;
4707 model_move->super.outputs = &model_move->output;
4708 model_move->super.output_size = 1;
4709 ccv_cnnp_model_copy_name(&model_move->super, name);
4710 return (ccv_cnnp_model_t*)model_move;
4711}
4712
4713static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context)
4714{
4715 const ccv_cnnp_model_move_t* const self = (const ccv_cnnp_model_move_t*)super;
4716 return ccv_cnnp_move(self->super.name);
4717}
4718
4719// MARK - "Making" Contiguous Layer
4720
4721typedef struct {
4722 ccv_cnnp_model_t super;
4723 ccv_nnc_tensor_symbol_t output;
4724} ccv_cnnp_model_contiguous_t;
4725
4726static 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)
4727{
4728 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);
4729 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"
, 4729, __extension__ __PRETTY_FUNCTION__); }));
4730 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", 4730, __extension__ __PRETTY_FUNCTION__
); }));
4731 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4732 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
4733 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
4734 {
4735 outputs[0] = inputs[0];
4736 return;
4737 }
4738 // Otherwise, we need to check its stride to know if it is contiguous.
4739 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4740 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
4741 // We identify permute by checking if the stride is not in descending order.
4742 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
4743 if (ccv_nnc_is_tensor_stride_packed(old_stride, params.dim))
4744 {
4745 outputs[0] = inputs[0];
4746 return;
4747 }
4748 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4749 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");
4750 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
4751}
4752
4753static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context);
4754
4755static const ccv_cnnp_model_vtab_t ccv_cnnp_contiguous_isa = {
4756 .build = _ccv_cnnp_contiguous_build,
4757 .copy = _ccv_cnnp_contiguous_copy,
4758};
4759
4760ccv_cnnp_model_t* ccv_cnnp_contiguous(const char* const name)
4761{
4762 ccv_cnnp_model_contiguous_t* const model_contiguous = (ccv_cnnp_model_contiguous_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_contiguous_t));
4763 model_contiguous->super.isa = &ccv_cnnp_contiguous_isa;
4764 model_contiguous->super.input_size = 1;
4765 model_contiguous->super.outputs = &model_contiguous->output;
4766 model_contiguous->super.output_size = 1;
4767 ccv_cnnp_model_copy_name(&model_contiguous->super, name);
4768 return (ccv_cnnp_model_t*)model_contiguous;
4769}
4770
4771static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context)
4772{
4773 const ccv_cnnp_model_contiguous_t* const self = (const ccv_cnnp_model_contiguous_t*)super;
4774 return ccv_cnnp_contiguous(self->super.name);
4775}
4776
4777// MARK - "Making" Copy Layer
4778
4779typedef struct {
4780 ccv_cnnp_model_t super;
4781 ccv_nnc_tensor_symbol_t output;
4782} ccv_cnnp_model_copy_t;
4783
4784static 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)
4785{
4786 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);
4787 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"
, 4787, __extension__ __PRETTY_FUNCTION__); }));
4788 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", 4788, __extension__ __PRETTY_FUNCTION__
); }));
4789 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4790 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
4791 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
4792 {
4793 outputs[0] = inputs[0];
4794 return;
4795 }
4796 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4797 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");
4798 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
4799}
4800
4801static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context);
4802
4803static const ccv_cnnp_model_vtab_t ccv_cnnp_copy_isa = {
4804 .build = _ccv_cnnp_copy_build,
4805 .copy = _ccv_cnnp_copy_copy,
4806};
4807
4808ccv_cnnp_model_t* ccv_cnnp_copy(const char* const name)
4809{
4810 ccv_cnnp_model_copy_t* const model_copy = (ccv_cnnp_model_copy_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_copy_t));
4811 model_copy->super.isa = &ccv_cnnp_copy_isa;
4812 model_copy->super.input_size = 1;
4813 model_copy->super.outputs = &model_copy->output;
4814 model_copy->super.output_size = 1;
4815 ccv_cnnp_model_copy_name(&model_copy->super, name);
4816 return (ccv_cnnp_model_t*)model_copy;
4817}
4818
4819static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context)
4820{
4821 const ccv_cnnp_model_copy_t* const self = (const ccv_cnnp_model_copy_t*)super;
4822 return ccv_cnnp_copy(self->super.name);
4823}
4824
4825// MARK - All-To-All Layer
4826
4827typedef struct {
4828 ccv_cnnp_model_t super;
4829 int axis;
4830 ccv_nnc_tensor_symbol_t outputs[1];
4831} ccv_cnnp_model_all_to_all_t;
4832
4833static void _ccv_cnnp_all_to_all_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)
4834{
4835 ccv_cnnp_model_all_to_all_t* const self = (ccv_cnnp_model_all_to_all_t*)super;
4836 PRINT(CCV_CLI_VERBOSE, "[cnnp_all_to_all_build] - axis: %d\n", self->axis)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_all_to_all_build] - axis: %d\n", self->axis
); fflush(stdout); } } while (0);
4837 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", 4837, __extension__ __PRETTY_FUNCTION__
); }));
4838 assert(output_size == self->super.output_size)((void) sizeof ((output_size == self->super.output_size) ?
1 : 0), __extension__ ({ if (output_size == self->super.output_size
) ; else __assert_fail ("output_size == self->super.output_size"
, "ccv_cnnp_model_addons.c", 4838, __extension__ __PRETTY_FUNCTION__
); }));
4839 assert(input_size == output_size)((void) sizeof ((input_size == output_size) ? 1 : 0), __extension__
({ if (input_size == output_size) ; else __assert_fail ("input_size == output_size"
, "ccv_cnnp_model_addons.c", 4839, __extension__ __PRETTY_FUNCTION__
); }));
4840 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", 4840, __extension__ __PRETTY_FUNCTION__
); }));
4841 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4842 const int nd = ccv_nnc_tensor_nd(input_params.dim);
4843 assert(self->axis >= 0 && self->axis < nd)((void) sizeof ((self->axis >= 0 && self->axis
< nd) ? 1 : 0), __extension__ ({ if (self->axis >= 0
&& self->axis < nd) ; else __assert_fail ("self->axis >= 0 && self->axis < nd"
, "ccv_cnnp_model_addons.c", 4843, __extension__ __PRETTY_FUNCTION__
); }));
4844 assert(input_params.dim[self->axis] % input_size == 0)((void) sizeof ((input_params.dim[self->axis] % input_size
== 0) ? 1 : 0), __extension__ ({ if (input_params.dim[self->
axis] % input_size == 0) ; else __assert_fail ("input_params.dim[self->axis] % input_size == 0"
, "ccv_cnnp_model_addons.c", 4844, __extension__ __PRETTY_FUNCTION__
); }));
4845 int i;
4846 for (i = 0; i < input_size; i++)
4847 {
4848 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
4849 assert(params.format == input_params.format)((void) sizeof ((params.format == input_params.format) ? 1 : 0
), __extension__ ({ if (params.format == input_params.format)
; else __assert_fail ("params.format == input_params.format"
, "ccv_cnnp_model_addons.c", 4849, __extension__ __PRETTY_FUNCTION__
); }));
4850 assert(params.datatype == input_params.datatype)((void) sizeof ((params.datatype == input_params.datatype) ? 1
: 0), __extension__ ({ if (params.datatype == input_params.datatype
) ; else __assert_fail ("params.datatype == input_params.datatype"
, "ccv_cnnp_model_addons.c", 4850, __extension__ __PRETTY_FUNCTION__
); }));
4851 assert(CCV_TENSOR_GET_MEMORY(params.type) == CCV_TENSOR_GET_MEMORY(input_params.type))((void) sizeof ((((params.type) & 0x3) == ((input_params.
type) & 0x3)) ? 1 : 0), __extension__ ({ if (((params.type
) & 0x3) == ((input_params.type) & 0x3)) ; else __assert_fail
("CCV_TENSOR_GET_MEMORY(params.type) == CCV_TENSOR_GET_MEMORY(input_params.type)"
, "ccv_cnnp_model_addons.c", 4851, __extension__ __PRETTY_FUNCTION__
); }));
4852 assert(memcmp(params.dim, input_params.dim, sizeof(input_params.dim)) == 0)((void) sizeof ((memcmp(params.dim, input_params.dim, sizeof(
input_params.dim)) == 0) ? 1 : 0), __extension__ ({ if (memcmp
(params.dim, input_params.dim, sizeof(input_params.dim)) == 0
) ; else __assert_fail ("memcmp(params.dim, input_params.dim, sizeof(input_params.dim)) == 0"
, "ccv_cnnp_model_addons.c", 4852, __extension__ __PRETTY_FUNCTION__
); }));
4853 outputs[i] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4854 }
4855 ccv_nnc_graph_exec_symbol_new(graph, CMD_COMM_ALL_TO_ALL_FORWARD(self->axis)ccv_nnc_cmd(CCV_NNC_COMM_ALL_TO_ALL_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.all_to_all={.axis=self->axis}}), 0
), inputs, input_size, outputs, output_size, "all_to_all");
4856}
4857
4858static ccv_cnnp_model_t* _ccv_cnnp_all_to_all_copy(const ccv_cnnp_model_t* const super, void* const context);
4859
4860static const ccv_cnnp_model_vtab_t ccv_cnnp_all_to_all_isa = {
4861 .build = _ccv_cnnp_all_to_all_build,
4862 .copy = _ccv_cnnp_all_to_all_copy,
4863};
4864
4865ccv_cnnp_model_t* ccv_cnnp_all_to_all(const int count, const int axis, const char* const name)
4866{
4867 assert(count > 0)((void) sizeof ((count > 0) ? 1 : 0), __extension__ ({ if (
count > 0) ; else __assert_fail ("count > 0", "ccv_cnnp_model_addons.c"
, 4867, __extension__ __PRETTY_FUNCTION__); }));
4868 assert(axis >= 0)((void) sizeof ((axis >= 0) ? 1 : 0), __extension__ ({ if (
axis >= 0) ; else __assert_fail ("axis >= 0", "ccv_cnnp_model_addons.c"
, 4868, __extension__ __PRETTY_FUNCTION__); }));
4869 ccv_cnnp_model_all_to_all_t* const model_all_to_all = (ccv_cnnp_model_all_to_all_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_all_to_all_t) + sizeof(ccv_nnc_tensor_symbol_t) * (count - 1));
4870 model_all_to_all->super.isa = &ccv_cnnp_all_to_all_isa;
4871 model_all_to_all->super.input_size = count;
4872 model_all_to_all->super.outputs = model_all_to_all->outputs;
4873 model_all_to_all->super.output_size = count;
4874 model_all_to_all->axis = axis;
4875 ccv_cnnp_model_copy_name(&model_all_to_all->super, name);
4876 return (ccv_cnnp_model_t*)model_all_to_all;
4877}
4878
4879static ccv_cnnp_model_t* _ccv_cnnp_all_to_all_copy(const ccv_cnnp_model_t* const super, void* const context)
4880{
4881 const ccv_cnnp_model_all_to_all_t* const self = (const ccv_cnnp_model_all_to_all_t*)super;
4882 return ccv_cnnp_all_to_all(self->super.output_size, self->axis, self->super.name);
4883}
4884
4885// MARK - Scaled-Dot Product Attention Layer
4886
4887typedef struct {
4888 ccv_cnnp_model_t super;
4889 ccv_nnc_tensor_symbol_t output;
4890 ccv_nnc_tensor_symbol_t weights;
4891 ccv_nnc_tensor_symbol_t bias;
4892 float scale;
4893 int is_causal;
4894 int has_attn_mask;
4895 int is_varlen;
4896 int max_seqlen_q;
4897 int max_seqlen_kv;
4898 int flags;
4899 int attention_sinks;
4900 int sliding_window;
4901 int fused_unify_head_weights;
4902 int no_bias;
4903} ccv_cnnp_model_scaled_dot_product_attention_t;
4904
4905static 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)
4906{
4907 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);
4908 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", 4908, __extension__ __PRETTY_FUNCTION__
); }));
4909 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
4910 assert(input_size == (self->is_varlen ? 5 : (self->has_attn_mask ? 4 : 3)) + self->attention_sinks)((void) sizeof ((input_size == (self->is_varlen ? 5 : (self
->has_attn_mask ? 4 : 3)) + self->attention_sinks) ? 1 :
0), __extension__ ({ if (input_size == (self->is_varlen ?
5 : (self->has_attn_mask ? 4 : 3)) + self->attention_sinks
) ; else __assert_fail ("input_size == (self->is_varlen ? 5 : (self->has_attn_mask ? 4 : 3)) + self->attention_sinks"
, "ccv_cnnp_model_addons.c", 4910, __extension__ __PRETTY_FUNCTION__
); }));
4911 assert(!self->is_varlen || !self->has_attn_mask)((void) sizeof ((!self->is_varlen || !self->has_attn_mask
) ? 1 : 0), __extension__ ({ if (!self->is_varlen || !self
->has_attn_mask) ; else __assert_fail ("!self->is_varlen || !self->has_attn_mask"
, "ccv_cnnp_model_addons.c", 4911, __extension__ __PRETTY_FUNCTION__
); }));
4912 assert(!self->is_varlen || !self->fused_unify_head_weights)((void) sizeof ((!self->is_varlen || !self->fused_unify_head_weights
) ? 1 : 0), __extension__ ({ if (!self->is_varlen || !self
->fused_unify_head_weights) ; else __assert_fail ("!self->is_varlen || !self->fused_unify_head_weights"
, "ccv_cnnp_model_addons.c", 4912, __extension__ __PRETTY_FUNCTION__
); }));
4913 const ccv_nnc_tensor_param_t q_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4914 const ccv_nnc_tensor_param_t k_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
4915 const ccv_nnc_tensor_param_t v_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
4916 const int sink_idx = self->is_varlen ? 5 : (3 + self->has_attn_mask);
4917 const ccv_nnc_tensor_param_t sinks_params = self->attention_sinks ? ccv_nnc_tensor_symbol_params(graph, inputs[sink_idx]) : (ccv_nnc_tensor_param_t){};
4918 const ccv_nnc_tensor_param_t attn_mask_params = self->has_attn_mask ? ccv_nnc_tensor_symbol_params(graph, inputs[3]) : (ccv_nnc_tensor_param_t){};
4919 const ccv_nnc_tensor_param_t q_seq_offsets_params = self->is_varlen ? ccv_nnc_tensor_symbol_params(graph, inputs[3]) : (ccv_nnc_tensor_param_t){};
4920 const ccv_nnc_tensor_param_t kv_seq_offsets_params = self->is_varlen ? ccv_nnc_tensor_symbol_params(graph, inputs[4]) : (ccv_nnc_tensor_param_t){};
4921 const int v_nd = ccv_nnc_tensor_nd(v_params.dim);
4922 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", 4922, __extension__ __PRETTY_FUNCTION__
); }));
4923 const int hEv = (v_nd == 3 ? 1 : v_params.dim[2]) * v_params.dim[v_nd - 1];
4924 ccv_nnc_tensor_param_t weights_params = q_params;
4925 memset(weights_params.dim, 0, sizeof(weights_params.dim));
4926 weights_params.dim[0] = hEv;
4927 weights_params.dim[1] = hEv;
4928 ccv_nnc_tensor_param_t bias_params = q_params;
4929 memset(bias_params.dim, 0, sizeof(bias_params.dim));
4930 bias_params.dim[0] = hEv;
4931 ccv_nnc_cmd_t cmd = {0};
4932 cmd.cmd = CCV_NNC_SCALED_DOT_PRODUCT_ATTENTION_FORWARD;
4933 cmd.info.scaled_dot_product_attention.scale = self->scale;
4934 cmd.info.scaled_dot_product_attention.is_causal = self->is_causal;
4935 cmd.info.scaled_dot_product_attention.is_varlen = self->is_varlen;
4936 cmd.info.scaled_dot_product_attention.max_seqlen_q = self->max_seqlen_q;
4937 cmd.info.scaled_dot_product_attention.max_seqlen_kv = self->max_seqlen_kv;
4938 cmd.info.scaled_dot_product_attention.flags = self->flags;
4939 cmd.info.scaled_dot_product_attention.attention_sinks = self->attention_sinks;
4940 cmd.info.scaled_dot_product_attention.sliding_window = self->sliding_window;
4941 ccv_nnc_tensor_param_t output_params[3];
4942 ccv_nnc_tensor_symbol_t output;
4943 ccv_nnc_tensor_symbol_t saved_softmax_lse;
4944 ccv_nnc_tensor_symbol_t saved_v_proj = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
4945 ccv_nnc_tensor_symbol_t attn_mask = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
4946 ccv_nnc_tensor_symbol_t weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
4947 ccv_nnc_tensor_symbol_t bias = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
4948 ccv_nnc_tensor_symbol_t sinks = self->attention_sinks ? inputs[sink_idx] : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
4949 if (self->has_attn_mask)
4950 attn_mask = inputs[3];
4951 if (self->is_varlen)
4952 {
4953 ccv_nnc_tensor_param_t input_params[9] = {
4954 q_params,
4955 k_params,
4956 v_params,
4957 (ccv_nnc_tensor_param_t){},
4958 (ccv_nnc_tensor_param_t){},
4959 (ccv_nnc_tensor_param_t){},
4960 q_seq_offsets_params,
4961 kv_seq_offsets_params,
4962 sinks_params,
4963 };
4964 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 8, ccv_nnc_no_hint, output_params, 2);
4965 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4966 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4967 if (self->attention_sinks)
4968 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, inputs[3], inputs[4], sinks)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, inputs[3], inputs[4], sinks}, (1 +1 +1 +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 -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");
4969 else
4970 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, inputs[3], inputs[4])(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, (const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, inputs[3], inputs[4]}, (1 +1 +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 -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");
4971 } else if (self->fused_unify_head_weights)
4972 {
4973 if (!self->weights.graph)
4974 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
4975 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"
, 4975, __extension__ __PRETTY_FUNCTION__); }));
4976 weights = ccv_cnnp_model_get_symbol(super, self->weights);
4977 if (!self->no_bias)
4978 {
4979 if (!self->bias.graph)
4980 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
4981 assert(self->bias.graph == graph)((void) sizeof ((self->bias.graph == graph) ? 1 : 0), __extension__
({ if (self->bias.graph == graph) ; else __assert_fail ("self->bias.graph == graph"
, "ccv_cnnp_model_addons.c", 4981, __extension__ __PRETTY_FUNCTION__
); }));
4982 bias = ccv_cnnp_model_get_symbol(super, self->bias);
4983 }
4984 ccv_nnc_tensor_param_t input_params[9] = {
4985 q_params,
4986 k_params,
4987 v_params,
4988 attn_mask_params,
4989 weights_params,
4990 bias_params,
4991 (ccv_nnc_tensor_param_t){},
4992 (ccv_nnc_tensor_param_t){},
4993 sinks_params,
4994 };
4995 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 6, ccv_nnc_no_hint, output_params, 3);
4996 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4997 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
4998 saved_v_proj = ccv_nnc_tensor_symbol_new(graph, output_params[2], 0);
4999 if (self->attention_sinks)
5000 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], attn_mask, weights, bias, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, sinks)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], attn_mask, weights, bias, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, sinks}, (1 +1 +1 +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 -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");
5001 else
5002 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");
5003 } else {
5004 ccv_nnc_tensor_param_t input_params[9] = {
5005 q_params,
5006 k_params,
5007 v_params,
5008 attn_mask_params,
5009 (ccv_nnc_tensor_param_t){},
5010 (ccv_nnc_tensor_param_t){},
5011 (ccv_nnc_tensor_param_t){},
5012 (ccv_nnc_tensor_param_t){},
5013 sinks_params,
5014 };
5015 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 3, ccv_nnc_no_hint, output_params, 2);
5016 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
5017 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
5018 if (self->attention_sinks)
5019 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], attn_mask, weights, bias, NO_TENSOR_SYMBOL, NO_TENSOR_SYMBOL, sinks)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], attn_mask, weights, bias, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, (const ccv_nnc_tensor_symbol_t
){.d = CCV_NNC_NO_TENSOR_SYMBOL}, sinks}, (1 +1 +1 +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 -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");
5020 else
5021 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");
5022 }
5023 outputs[0] = output;
5024}
5025
5026static 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)
5027{
5028 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5029 if (self->weights.graph)
5030 {
5031 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"
, 5031, __extension__ __PRETTY_FUNCTION__); }));
5032 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
5033 const int c = weight_params.dim[1];
5034 const float std = sqrtf(2) / sqrtf(c);
5035 const float bound = sqrtf(3) * std;
5036 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);
5037 if (self->bias.graph)
5038 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);
5039 }
5040}
5041
5042static 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)
5043{
5044 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5045 if (self->weights.graph)
5046 {
5047 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"
, 5047, __extension__ __PRETTY_FUNCTION__); }));
5048 add_to_array(parameters, self->weights, is_trainable);
5049 if (self->bias.graph)
5050 add_to_array(parameters, self->bias, is_trainable);
5051 }
5052}
5053
5054static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context);
5055
5056static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_isa = {
5057 .build = _ccv_cnnp_scaled_dot_product_attention_build,
5058 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
5059};
5060
5061static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_fused_isa = {
5062 .build = _ccv_cnnp_scaled_dot_product_attention_build,
5063 .init_states = _ccv_cnnp_scaled_dot_product_attention_init_states,
5064 .add_to_parameter = _ccv_cnnp_scaled_dot_product_attention_add_to_parameter,
5065 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
5066};
5067
5068ccv_cnnp_model_t* ccv_cnnp_scaled_dot_product_attention(const float scale, const int is_causal, const int has_attn_mask, const int is_varlen, const int max_seqlen_q, const int max_seqlen_kv, const int flags, const int attention_sinks, const int sliding_window, const int fused_unify_head_weights, const int no_bias, const int is_trainable, const char* const name)
5069{
5070 assert(!is_varlen || !has_attn_mask)((void) sizeof ((!is_varlen || !has_attn_mask) ? 1 : 0), __extension__
({ if (!is_varlen || !has_attn_mask) ; else __assert_fail ("!is_varlen || !has_attn_mask"
, "ccv_cnnp_model_addons.c", 5070, __extension__ __PRETTY_FUNCTION__
); }));
5071 assert(!is_varlen || !fused_unify_head_weights)((void) sizeof ((!is_varlen || !fused_unify_head_weights) ? 1
: 0), __extension__ ({ if (!is_varlen || !fused_unify_head_weights
) ; else __assert_fail ("!is_varlen || !fused_unify_head_weights"
, "ccv_cnnp_model_addons.c", 5071, __extension__ __PRETTY_FUNCTION__
); }));
5072 assert(sliding_window == 0 || is_causal)((void) sizeof ((sliding_window == 0 || is_causal) ? 1 : 0), __extension__
({ if (sliding_window == 0 || is_causal) ; else __assert_fail
("sliding_window == 0 || is_causal", "ccv_cnnp_model_addons.c"
, 5072, __extension__ __PRETTY_FUNCTION__); }));
5073 assert(sliding_window == 0 || !is_varlen)((void) sizeof ((sliding_window == 0 || !is_varlen) ? 1 : 0),
__extension__ ({ if (sliding_window == 0 || !is_varlen) ; else
__assert_fail ("sliding_window == 0 || !is_varlen", "ccv_cnnp_model_addons.c"
, 5073, __extension__ __PRETTY_FUNCTION__); }));
5074 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));
5075 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;
5076 const int has_attention_sinks = attention_sinks ? 1 : 0;
5077 model_scaled_dot_product_attention->super.input_size = (is_varlen ? 5 : (has_attn_mask ? 4 : 3)) + has_attention_sinks;
5078 model_scaled_dot_product_attention->super.outputs = &model_scaled_dot_product_attention->output;
5079 model_scaled_dot_product_attention->super.output_size = 1;
5080 model_scaled_dot_product_attention->super.is_trainable = is_trainable;
5081 ccv_cnnp_model_copy_name(&model_scaled_dot_product_attention->super, name);
5082 model_scaled_dot_product_attention->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5083 model_scaled_dot_product_attention->weights.graph = 0;
5084 model_scaled_dot_product_attention->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
5085 model_scaled_dot_product_attention->bias.graph = 0;
5086 model_scaled_dot_product_attention->scale = scale;
5087 model_scaled_dot_product_attention->is_causal = is_causal;
5088 model_scaled_dot_product_attention->has_attn_mask = has_attn_mask;
5089 model_scaled_dot_product_attention->is_varlen = is_varlen;
5090 model_scaled_dot_product_attention->max_seqlen_q = max_seqlen_q;
5091 model_scaled_dot_product_attention->max_seqlen_kv = max_seqlen_kv;
5092 model_scaled_dot_product_attention->flags = flags;
5093 model_scaled_dot_product_attention->attention_sinks = has_attention_sinks;
5094 model_scaled_dot_product_attention->sliding_window = sliding_window;
5095 model_scaled_dot_product_attention->fused_unify_head_weights = fused_unify_head_weights;
5096 model_scaled_dot_product_attention->no_bias = no_bias;
5097 return (ccv_cnnp_model_t*)model_scaled_dot_product_attention;
5098}
5099
5100static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context)
5101{
5102 const ccv_cnnp_model_scaled_dot_product_attention_t* const self = (const ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5103 return ccv_cnnp_scaled_dot_product_attention(self->scale, self->is_causal, self->has_attn_mask, self->is_varlen, self->max_seqlen_q, self->max_seqlen_kv, self->flags, self->attention_sinks, self->sliding_window, self->fused_unify_head_weights, self->no_bias, self->super.is_trainable, self->super.name);
5104}
5105
5106// MARK - Debug Layer
5107
5108typedef struct {
5109 ccv_cnnp_model_t super;
5110 ccv_nnc_tensor_symbol_t output;
5111 ccv_cnnp_model_debug_f debugger;
5112 ccv_cnnp_model_debug_context_deinit_f debug_deinit;
5113 ccv_cnnp_model_debug_context_copy_f debug_copy;
5114 void* debug_context;
5115} ccv_cnnp_model_debug_t;
5116
5117static 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)
5118{
5119 if (cmd.cmd == CCV_NNC_CUSTOM_BACKWARD)
5120 {
5121 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", 5121, __extension__ __PRETTY_FUNCTION__
); }));
5122 }
5123 ccv_cnnp_model_debug_t* const self = (ccv_cnnp_model_debug_t*)cmd.data;
5124 self->debugger(inputs, input_size, stream_context, self->debug_context);
5125 return CCV_NNC_EXEC_SUCCESS;
5126}
5127
5128static ccv_nnc_cmd_vtab_t ccv_cnnp_debug_exec_isa = {
5129 .exec = _ccv_cnnp_debug_exec
5130};
5131
5132static 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)
5133{
5134 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);
5135 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", 5135, __extension__ __PRETTY_FUNCTION__
); }));
5136 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", 5136, __extension__ __PRETTY_FUNCTION__
); }));
5137 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
5138 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5139 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
5140 {
5141 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {0};
5142 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
5143 ccv_nnc_tensor_get_stride(output_params.dim, stride);
5144 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
5145 } else {
5146 int old_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
5147 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
5148 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], old_ofs, old_stride);
5149 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, to, old_ofs, old_stride, output_params, 0);
5150 }
5151 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);
5152 cmd.data = self;
5153 ccv_nnc_graph_exec_symbol_t make_debug = ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, input_size, outputs, 1, "debug");
5154 // Disable any optimizations.
5155 ccv_nnc_graph_exec_symbol_set_flags(graph, make_debug, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
5156}
5157
5158static void _ccv_cnnp_debug_deinit(ccv_cnnp_model_t* const super)
5159{
5160 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
5161 if (self->debug_deinit && self->debug_context)
5162 self->debug_deinit(self->debug_context);
5163}
5164
5165static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context);
5166
5167static const ccv_cnnp_model_vtab_t ccv_cnnp_debug_isa = {
5168 .build = _ccv_cnnp_debug_build,
5169 .deinit = _ccv_cnnp_debug_deinit,
5170 .copy = _ccv_cnnp_debug_copy,
5171};
5172
5173ccv_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)
5174{
5175 ccv_cnnp_model_debug_t* const model_debug = (ccv_cnnp_model_debug_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_debug_t));
5176 model_debug->super.isa = &ccv_cnnp_debug_isa;
5177 model_debug->super.input_size = 0;
5178 model_debug->super.outputs = &model_debug->output;
5179 model_debug->super.output_size = 1;
5180 model_debug->debugger = func;
5181 model_debug->debug_context = context;
5182 model_debug->debug_deinit = deinit;
5183 model_debug->debug_copy = copy;
5184 ccv_cnnp_model_copy_name(&model_debug->super, name);
5185 return (ccv_cnnp_model_t*)model_debug;
5186}
5187
5188static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context)
5189{
5190 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
5191 void* debug_context = self->debug_context;
5192 if (self->debug_copy && self->debug_context)
5193 debug_context = self->debug_copy(self->debug_context);
5194 return ccv_cnnp_debug(self->debugger, debug_context, self->debug_deinit, self->debug_copy, self->super.name);
5195}
5196
5197/// MARK - Sort layer.
5198
5199typedef struct {
5200 ccv_cnnp_model_t super;
5201 ccv_nnc_tensor_symbol_t outputs[2];
5202 int along_axis;
5203 int descending;
5204} ccv_cnnp_model_sort_t;
5205
5206static 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)
5207{
5208 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
5209 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);
5210 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5211 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", 5211, __extension__ __PRETTY_FUNCTION__
); }));
5212 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5213 params.datatype = CCV_32S;
5214 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5215 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");
5216}
5217
5218static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const self, void* const context);
5219
5220static const ccv_cnnp_model_vtab_t ccv_cnnp_sort_isa = {
5221 .build = _ccv_cnnp_sort_build,
5222 .copy = _ccv_cnnp_sort_copy,
5223};
5224
5225ccv_cnnp_model_t* ccv_cnnp_sort(const int along_axis, const int descending, const char* const name)
5226{
5227 ccv_cnnp_model_sort_t* const model_sort = (ccv_cnnp_model_sort_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sort_t));
5228 model_sort->super.isa = &ccv_cnnp_sort_isa;
5229 model_sort->super.input_size = 0;
5230 model_sort->super.outputs = model_sort->outputs;
5231 model_sort->super.output_size = 2;
5232 model_sort->along_axis = along_axis;
5233 model_sort->descending = descending;
5234 ccv_cnnp_model_copy_name(&model_sort->super, name);
5235 return (ccv_cnnp_model_t*)model_sort;
5236}
5237
5238static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const super, void* const context)
5239{
5240 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
5241 return ccv_cnnp_sort(self->along_axis, self->descending, self->super.name);
5242}
5243
5244/// MARK - Partition layer.
5245
5246typedef struct {
5247 ccv_cnnp_model_t super;
5248 ccv_nnc_tensor_symbol_t outputs[2];
5249 int kth;
5250 int along_axis;
5251 int descending;
5252} ccv_cnnp_model_partition_t;
5253
5254static 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)
5255{
5256 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
5257 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);
5258 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5259 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", 5259, __extension__ __PRETTY_FUNCTION__
); }));
5260 if (self->kth > 0)
5261 params.dim[self->along_axis] = self->kth;
5262 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5263 params.datatype = CCV_32S;
5264 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5265 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");
5266}
5267
5268static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const self, void* const context);
5269
5270static const ccv_cnnp_model_vtab_t ccv_cnnp_partition_isa = {
5271 .build = _ccv_cnnp_partition_build,
5272 .copy = _ccv_cnnp_partition_copy,
5273};
5274
5275ccv_cnnp_model_t* ccv_cnnp_partition(const int kth, const int along_axis, const int descending, const char* const name)
5276{
5277 ccv_cnnp_model_partition_t* const model_partition = (ccv_cnnp_model_partition_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_partition_t));
5278 model_partition->super.isa = &ccv_cnnp_partition_isa;
5279 model_partition->super.input_size = 0;
5280 model_partition->super.outputs = model_partition->outputs;
5281 model_partition->super.output_size = 2;
5282 model_partition->kth = kth;
5283 model_partition->along_axis = along_axis;
5284 model_partition->descending = descending;
5285 ccv_cnnp_model_copy_name(&model_partition->super, name);
5286 return (ccv_cnnp_model_t*)model_partition;
5287}
5288
5289static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const super, void* const context)
5290{
5291 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
5292 return ccv_cnnp_partition(self->kth, self->along_axis, self->descending, self->super.name);
5293}
5294
5295/// MARK - Unique consecutive layer.
5296
5297typedef struct {
5298 ccv_cnnp_model_t super;
5299 ccv_nnc_tensor_symbol_t outputs[2];
5300 int bincount;
5301} ccv_cnnp_model_unique_consecutive_t;
5302
5303static 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)
5304{
5305 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
5306 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);
5307 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5308 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", 5308, __extension__ __PRETTY_FUNCTION__
); }));
5309 if (self->bincount > 0)
5310 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; }
);
5311 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5312 params.datatype = CCV_32S;
5313 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5314 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");
5315}
5316
5317static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const self, void* const context);
5318
5319static const ccv_cnnp_model_vtab_t ccv_cnnp_unique_consecutive_isa = {
5320 .build = _ccv_cnnp_unique_consecutive_build,
5321 .copy = _ccv_cnnp_unique_consecutive_copy,
5322};
5323
5324ccv_cnnp_model_t* ccv_cnnp_unique_consecutive(const int bincount, const char* const name)
5325{
5326 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));
5327 model_unique_consecutive->super.isa = &ccv_cnnp_unique_consecutive_isa;
5328 model_unique_consecutive->super.input_size = 0;
5329 model_unique_consecutive->super.outputs = model_unique_consecutive->outputs;
5330 model_unique_consecutive->super.output_size = 2;
5331 model_unique_consecutive->bincount = bincount;
5332 ccv_cnnp_model_copy_name(&model_unique_consecutive->super, name);
5333 return (ccv_cnnp_model_t*)model_unique_consecutive;
5334}
5335
5336static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const super, void* const context)
5337{
5338 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
5339 return ccv_cnnp_unique_consecutive(self->bincount, self->super.name);
5340}
5341
5342/// MARK - Scatter add layer.
5343
5344typedef struct {
5345 ccv_cnnp_model_t super;
5346 ccv_nnc_tensor_symbol_t output;
5347 int bincount;
5348 int count_per_output;
5349} ccv_cnnp_model_scatter_add_t;
5350
5351static 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)
5352{
5353 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
5354 PRINT(CCV_CLI_VERBOSE, "[cnnp_scatter_add_build] - bincount: %d, count_per_output: %d\n", self->bincount, self->count_per_output)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_scatter_add_build] - bincount: %d, count_per_output: %d\n"
, self->bincount, self->count_per_output); fflush(stdout
); } } while (0);
5355 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5356 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", 5356, __extension__ __PRETTY_FUNCTION__
); }));
5357 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", 5357, __extension__ __PRETTY_FUNCTION__
); }));
5358 params.dim[0] = self->bincount;
5359 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5360 ccv_nnc_graph_exec_symbol_new(graph, CMD_SCATTER_ADD_FORWARD(self->bincount, self->count_per_output)ccv_nnc_cmd(CCV_NNC_SCATTER_ADD_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.scatter_add={.bincount=self->bincount
,.count_per_output=self->count_per_output}}), 0), inputs, input_size, outputs, output_size, "scatter_add");
5361}
5362
5363static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const self, void* const context);
5364
5365static const ccv_cnnp_model_vtab_t ccv_cnnp_scatter_add_isa = {
5366 .build = _ccv_cnnp_scatter_add_build,
5367 .copy = _ccv_cnnp_scatter_add_copy,
5368};
5369
5370ccv_cnnp_model_t* ccv_cnnp_scatter_add(const int bincount, const int count_per_output, const char* const name)
5371{
5372 assert(bincount > 0)((void) sizeof ((bincount > 0) ? 1 : 0), __extension__ ({ if
(bincount > 0) ; else __assert_fail ("bincount > 0", "ccv_cnnp_model_addons.c"
, 5372, __extension__ __PRETTY_FUNCTION__); }));
5373 assert(count_per_output >= 0)((void) sizeof ((count_per_output >= 0) ? 1 : 0), __extension__
({ if (count_per_output >= 0) ; else __assert_fail ("count_per_output >= 0"
, "ccv_cnnp_model_addons.c", 5373, __extension__ __PRETTY_FUNCTION__
); }));
5374 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));
5375 model_scatter_add->super.isa = &ccv_cnnp_scatter_add_isa;
5376 model_scatter_add->super.input_size = 0;
5377 model_scatter_add->super.outputs = &model_scatter_add->output;
5378 model_scatter_add->super.output_size = 1;
5379 model_scatter_add->bincount = bincount;
5380 model_scatter_add->count_per_output = count_per_output;
5381 ccv_cnnp_model_copy_name(&model_scatter_add->super, name);
5382 return (ccv_cnnp_model_t*)model_scatter_add;
5383}
5384
5385static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const super, void* const context)
5386{
5387 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
5388 return ccv_cnnp_scatter_add(self->bincount, self->count_per_output, self->super.name);
5389}
5390
5391// MARK - Segmented Dense Layer
5392
5393typedef struct {
5394 ccv_cnnp_model_t super;
5395 ccv_nnc_tensor_symbol_t output;
5396 ccv_nnc_tensor_symbol_t weights;
5397 ccv_nnc_tensor_symbol_t bias;
5398 int segments;
5399 int count;
5400 int no_bias;
5401 int flags;
5402} ccv_cnnp_model_segmented_dense_t;
5403
5404static 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)
5405{
5406 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5407 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);
5408 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"
, 5408, __extension__ __PRETTY_FUNCTION__); }));
5409 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", 5409, __extension__ __PRETTY_FUNCTION__
); }));
5410 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5411 const ccv_nnc_tensor_param_t indices_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
5412 const ccv_nnc_tensor_param_t counts_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
5413 ccv_nnc_tensor_param_t weights_params = params;
5414 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5415 weights_params.dim[0] = self->segments;
5416 weights_params.dim[1] = self->count;
5417 weights_params.dim[2] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
5418 if (!self->weights.graph)
5419 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
5420 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"
, 5420, __extension__ __PRETTY_FUNCTION__); }));
5421 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
5422 ccv_nnc_tensor_param_t bias_params = params;
5423 memset(bias_params.dim, 0, sizeof(bias_params.dim));
5424 bias_params.dim[0] = self->segments;
5425 bias_params.dim[1] = self->count;
5426 ccv_nnc_cmd_t cmd = {0};
5427 cmd.cmd = CCV_NNC_SEGMENTED_GEMM_FORWARD;
5428 cmd.info.blas.a[0] = 1;
5429 cmd.info.blas.a[1] = 1;
5430 cmd.info.blas.transpose_b[0] = 1;
5431 cmd.info.blas.transpose_b[1] = 2;
5432 cmd.info.blas.flags = self->flags;
5433 ccv_nnc_tensor_param_t output_params;
5434 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
5435 params, indices_params, counts_params,
5436 weights_params,
5437 bias_params,
5438 }, 5, ccv_nnc_no_hint, &output_params, 1);
5439 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
5440 if (self->no_bias)
5441 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], 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");
5442 else {
5443 if (!self->bias.graph)
5444 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
5445 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
5446 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], inputs[2], weights, bias)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], inputs
[2], weights, 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");
5447 }
5448 outputs[0] = output;
5449}
5450
5451static 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)
5452{
5453 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5454 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
5455 const int c = weight_params.dim[1];
5456 const float std = sqrtf(2) / sqrtf(c);
5457 const float bound = sqrtf(3) * std;
5458 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);
5459 if (self->bias.graph)
5460 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);
5461}
5462
5463static 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)
5464{
5465 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5466 add_to_array(parameters, self->weights, is_trainable);
5467 if (self->bias.graph)
5468 add_to_array(parameters, self->bias, is_trainable);
5469}
5470
5471static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
5472
5473static const ccv_cnnp_model_vtab_t ccv_cnnp_segmented_dense_isa = {
5474 .build = _ccv_cnnp_segmented_dense_build,
5475 .init_states = _ccv_cnnp_segmented_dense_init_states,
5476 .add_to_parameter = _ccv_cnnp_segmented_dense_add_to_parameter,
5477 .copy = _ccv_cnnp_segmented_dense_copy,
5478};
5479
5480ccv_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)
5481{
5482 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));
5483 model_segmented_dense->super.isa = &ccv_cnnp_segmented_dense_isa;
5484 model_segmented_dense->super.input_size = 3;
5485 model_segmented_dense->super.outputs = &model_segmented_dense->output;
5486 model_segmented_dense->super.output_size = 1;
5487 model_segmented_dense->super.is_trainable = is_trainable;
5488 ccv_cnnp_model_copy_name(&model_segmented_dense->super, name);
5489 model_segmented_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5490 model_segmented_dense->weights.graph = 0;
5491 model_segmented_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
5492 model_segmented_dense->bias.graph = 0;
5493 model_segmented_dense->segments = segments;
5494 model_segmented_dense->count = count;
5495 model_segmented_dense->no_bias = no_bias;
5496 model_segmented_dense->flags = flags;
5497 return (ccv_cnnp_model_t*)model_segmented_dense;
5498}
5499
5500static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
5501{
5502 const ccv_cnnp_model_segmented_dense_t* const self = (const ccv_cnnp_model_segmented_dense_t*)super;
5503 return ccv_cnnp_segmented_dense(self->segments, self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
5504}
5505
5506// MARK - Segmented SwiGLU Layer
5507
5508typedef struct {
5509 ccv_cnnp_model_t super;
5510 ccv_nnc_tensor_symbol_t output;
5511 ccv_nnc_tensor_symbol_t gate_weights;
5512 ccv_nnc_tensor_symbol_t up_weights;
5513 int segments;
5514 int count;
5515 float clamp;
5516} ccv_cnnp_model_segmented_swiglu_t;
5517
5518static void _ccv_cnnp_segmented_swiglu_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)
5519{
5520 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5521 PRINT(CCV_CLI_VERBOSE, "[cnnp_segmented_swiglu_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_segmented_swiglu_build] -\n"); fflush(stdout
); } } while (0);
5522 assert(input_size == 4)((void) sizeof ((input_size == 4) ? 1 : 0), __extension__ ({ if
(input_size == 4) ; else __assert_fail ("input_size == 4", "ccv_cnnp_model_addons.c"
, 5522, __extension__ __PRETTY_FUNCTION__); }));
5523 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", 5523, __extension__ __PRETTY_FUNCTION__
); }));
5524 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5525 const int params_nd = ccv_nnc_tensor_nd(params.dim);
5526 assert(params_nd >= 1)((void) sizeof ((params_nd >= 1) ? 1 : 0), __extension__ (
{ if (params_nd >= 1) ; else __assert_fail ("params_nd >= 1"
, "ccv_cnnp_model_addons.c", 5526, __extension__ __PRETTY_FUNCTION__
); }));
5527 ccv_nnc_tensor_param_t weights_params = params;
5528 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5529 weights_params.dim[0] = self->segments;
5530 weights_params.dim[1] = self->count;
5531 weights_params.dim[2] = params.dim[params_nd - 1];
5532 if (!self->gate_weights.graph)
5533 self->gate_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "gate.weight");
5534 if (!self->up_weights.graph)
5535 self->up_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "up.weight");
5536 assert(self->gate_weights.graph == graph)((void) sizeof ((self->gate_weights.graph == graph) ? 1 : 0
), __extension__ ({ if (self->gate_weights.graph == graph)
; else __assert_fail ("self->gate_weights.graph == graph"
, "ccv_cnnp_model_addons.c", 5536, __extension__ __PRETTY_FUNCTION__
); }));
5537 assert(self->up_weights.graph == graph)((void) sizeof ((self->up_weights.graph == graph) ? 1 : 0)
, __extension__ ({ if (self->up_weights.graph == graph) ; else
__assert_fail ("self->up_weights.graph == graph", "ccv_cnnp_model_addons.c"
, 5537, __extension__ __PRETTY_FUNCTION__); }));
5538 const ccv_nnc_tensor_symbol_t gate_weights = ccv_cnnp_model_get_symbol(super, self->gate_weights);
5539 const ccv_nnc_tensor_symbol_t up_weights = ccv_cnnp_model_get_symbol(super, self->up_weights);
5540 const ccv_nnc_cmd_t cmd = CMD_SEGMENTED_SWIGLU_FORWARD(self->clamp)ccv_nnc_cmd(CCV_NNC_SEGMENTED_SWIGLU_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.segmented_swiglu={.clamp=self->clamp
}}), 0);
5541 const ccv_nnc_tensor_symbol_t command_inputs[] = {
5542 inputs[0], inputs[1], inputs[2], gate_weights, up_weights, inputs[3],
5543 };
5544 ccv_nnc_tensor_param_t command_input_params[6];
5545 int i;
5546 for (i = 0; i < 6; i++)
5547 command_input_params[i] = ccv_nnc_tensor_symbol_params(graph, command_inputs[i]);
5548 ccv_nnc_tensor_param_t output_params;
5549 ccv_nnc_hint_tensor_auto(cmd, command_input_params, 6, ccv_nnc_no_hint, &output_params, 1);
5550 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
5551 ccv_nnc_graph_exec_symbol_new(graph, cmd, command_inputs, 6, outputs, 1, "segmented_swiglu");
5552}
5553
5554static void _ccv_cnnp_segmented_swiglu_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)
5555{
5556 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5557 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->gate_weights);
5558 const float bound = sqrtf(6.f / weight_params.dim[2]);
5559 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->gate_weights);
5560 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->up_weights);
5561}
5562
5563static void _ccv_cnnp_segmented_swiglu_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)
5564{
5565 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5566 add_to_array(parameters, self->gate_weights, is_trainable);
5567 add_to_array(parameters, self->up_weights, is_trainable);
5568}
5569
5570static ccv_cnnp_model_t* _ccv_cnnp_segmented_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context);
5571
5572static const ccv_cnnp_model_vtab_t ccv_cnnp_segmented_swiglu_isa = {
5573 .build = _ccv_cnnp_segmented_swiglu_build,
5574 .init_states = _ccv_cnnp_segmented_swiglu_init_states,
5575 .add_to_parameter = _ccv_cnnp_segmented_swiglu_add_to_parameter,
5576 .copy = _ccv_cnnp_segmented_swiglu_copy,
5577};
5578
5579ccv_cnnp_model_t* ccv_cnnp_segmented_swiglu(const int segments, const int count, const float clamp, const int is_trainable, const char* const name)
5580{
5581 ccv_cnnp_model_segmented_swiglu_t* const model = (ccv_cnnp_model_segmented_swiglu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_segmented_swiglu_t));
5582 model->super.isa = &ccv_cnnp_segmented_swiglu_isa;
5583 model->super.input_size = 4;
5584 model->super.outputs = &model->output;
5585 model->super.output_size = 1;
5586 model->super.is_trainable = is_trainable;
5587 ccv_cnnp_model_copy_name(&model->super, name);
5588 model->gate_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5589 model->up_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5590 model->segments = segments;
5591 model->count = count;
5592 model->clamp = clamp;
5593 return (ccv_cnnp_model_t*)model;
5594}
5595
5596static ccv_cnnp_model_t* _ccv_cnnp_segmented_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context)
5597{
5598 const ccv_cnnp_model_segmented_swiglu_t* const self = (const ccv_cnnp_model_segmented_swiglu_t*)super;
5599 return ccv_cnnp_segmented_swiglu(self->segments, self->count, self->clamp, self->super.is_trainable, self->super.name);
5600}