Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ccv_cnnp_model_addons.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +sse2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -fcoverage-compilation-dir=/home/liu/actions-runner/_work/ccv/ccv/lib/nnc -resource-dir /usr/local/lib/clang/19 -I ../ -I /usr/local/cuda/include -D HAVE_CBLAS -D HAVE_LIBPNG -D HAVE_LIBJPEG -D HAVE_FFTW3 -D HAVE_PTHREAD -D HAVE_LIBLINEAR -D HAVE_TESSERACT -D HAVE_AVCODEC -D HAVE_AVFORMAT -D HAVE_AVUTIL -D HAVE_SWSCALE -D HAVE_SSE2 -D HAVE_GSL -D HAVE_CUDA -D HAVE_CUDNN -D HAVE_NCCL -D USE_SYSTEM_CUB -I /usr/local/include -internal-isystem /usr/local/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/liu/actions-runner/_work/ccv/ccv/_analyze/2026-11-05-170145-808375-1 -x c ccv_cnnp_model_addons.c
1#include "ccv_nnc.h"
2#include "ccv_nnc_easy.h"
3#include "ccv_nnc_internal.h"
4#include "ccv_internal.h"
5#include "_ccv_cnnp_model.h"
6
7// MARK - Add-on Functions
8
9static int _ccv_cnnp_model_clip_grad_norm_reduce_norm2(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
10{
11 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
12 ccv_nnc_tensor_t* const old_norm2 = outputs[1 + device_id * 2];
13 ccv_nnc_tensor_t* const norm2 = outputs[1 + device_id * 2 + 1];
14 const int tensor_count = ccv_nnc_tensor_count(inputs[0]->info);
15 if (tensor_count == 1)
16 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(inputs[0], inputs[0])(ccv_nnc_tensor_t* []){inputs[0], inputs[0]}, (1 +1 +1 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
17 else {
18 ccv_nnc_cmd_exec(CMD_REDUCE_NORM2_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_NORM2_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0), hint, flags, TENSOR_LIST(inputs[0])(ccv_nnc_tensor_t* []){inputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
19 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(norm2, norm2)(ccv_nnc_tensor_t* []){norm2, norm2}, (1 +1 +1 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2)(ccv_nnc_tensor_t* []){norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
20 }
21 ccv_nnc_cmd_exec(CMD_ADD_FORWARD(1, 1)ccv_nnc_cmd(CCV_NNC_ADD_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1, 1}}}, 0), hint, flags, TENSOR_LIST(old_norm2, norm2)(ccv_nnc_tensor_t* []){old_norm2, norm2}, (1 +1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(old_norm2)(ccv_nnc_tensor_t* []){old_norm2}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
22 return CCV_NNC_EXEC_SUCCESS;
23}
24
25static ccv_nnc_cmd_vtab_t clip_grad_norm_reduce_norm2_vtab = {
26 .exec = _ccv_cnnp_model_clip_grad_norm_reduce_norm2
27};
28
29static int _ccv_cnnp_model_clip_grad_norm_scatter_norm2(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
30{
31 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
32 ccv_nnc_tensor_t* const norm2 = inputs[1 + device_id * 2];
33 ccv_nnc_cmd_exec(CMD_MUL_FORWARD(1)ccv_nnc_cmd(CCV_NNC_MUL_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={1,}}}, 0), hint, flags, TENSOR_LIST(inputs[0], norm2)(ccv_nnc_tensor_t* []){inputs[0], norm2}, (1 +1 +1 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(outputs[0])(ccv_nnc_tensor_t* []){outputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
34 return CCV_NNC_EXEC_SUCCESS;
35}
36
37static ccv_nnc_cmd_vtab_t clip_grad_norm_scatter_norm2_vtab = {
38 .exec = _ccv_cnnp_model_clip_grad_norm_scatter_norm2
39};
40
41void ccv_cnnp_model_parameters_clip_grad_norm(ccv_cnnp_model_t* const model, const ccv_cnnp_model_io_t parameters, int norm_type, float max_norm, ccv_nnc_stream_context_t* const stream_context)
42{
43 assert(norm_type == 2)((void) sizeof ((norm_type == 2) ? 1 : 0), __extension__ ({ if
(norm_type == 2) ; else __assert_fail ("norm_type == 2", "ccv_cnnp_model_addons.c"
, 43, __extension__ __PRETTY_FUNCTION__); }));
44 ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;
45 assert(compiled_data)((void) sizeof ((compiled_data) ? 1 : 0), __extension__ ({ if
(compiled_data) ; else __assert_fail ("compiled_data", "ccv_cnnp_model_addons.c"
, 45, __extension__ __PRETTY_FUNCTION__); }));
46 const int parallel_count = ccv_max(model->parallel_count, 1)({ typeof (model->parallel_count) _a = (model->parallel_count
); typeof (1) _b = (1); (_a > _b) ? _a : _b; });
47 ccv_nnc_tensor_t* norm2[parallel_count * 2];
48 ccv_nnc_tensor_t* max_normt[parallel_count];
49 const int stream_type = model->compiled_data->stream_type;
50 int i;
51 if (stream_type == CCV_STREAM_CONTEXT_GPU)
52 {
53 for (i = 0; i < parallel_count; i++)
54 {
55 ccv_nnc_tensor_param_t info = {
56 .type = CCV_TENSOR_GPU_MEMORY,
57 .format = CCV_TENSOR_FORMAT_NHWC,
58 .datatype = CCV_32F,
59 .dim = {1},
60 };
61 CCV_TENSOR_SET_DEVICE_ID(info.type, i)(info.type) = (((info.type) & ~0xfff00) | (((i) & 0xfff
) << 8));
62 norm2[i * 2] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
63 norm2[i * 2 + 1] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
64 max_normt[i] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
65 }
66 } else {
67 for (i = 0; i < parallel_count; i++)
68 {
69 ccv_nnc_tensor_param_t info = {
70 .type = CCV_TENSOR_CPU_MEMORY,
71 .format = CCV_TENSOR_FORMAT_NHWC,
72 .datatype = CCV_32F,
73 .dim = {1},
74 };
75 norm2[i * 2] = ccv_nnc_tensor_new(0, info, 0);
76 norm2[i * 2 + 1] = ccv_nnc_tensor_new(0, info, 0);
77 max_normt[i] = ccv_nnc_tensor_new(0, info, 0);
78 }
79 }
80 // zero out old norm2.
81 if (parallel_count > 1)
82 {
83 ccv_nnc_stream_context_t* streams[parallel_count];
84 ccv_nnc_stream_signal_t* signal;
85 if (stream_context)
86 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
87 for (i = 0; i < parallel_count; i++)
88 {
89 const int stream_type = CCV_TENSOR_GET_MEMORY(norm2[i * 2]->info.type)((norm2[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
90 const int device_id = CCV_TENSOR_GET_DEVICE_ID(norm2[i * 2]->info.type)(((norm2[i * 2]->info.type) & 0xfff00) >> 8);
91 int type = stream_type;
92 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
93 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
94 // Wait signal to finish.
95 if (stream_context)
96 ccv_nnc_stream_context_wait_signal(stream_0, signal);
97 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
98 if (stream_context)
99 {
100 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
101 ccv_nnc_stream_context_wait_signal(stream_context, signal);
102 }
103 streams[i] = stream_0;
104 }
105 // If this should be blocking, blocking it.
106 if (!stream_context)
107 for (i = 0; i < parallel_count; i++)
108 if (streams[i])
109 ccv_nnc_stream_context_wait(streams[i]);
110 } else {
111 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
112 }
113 // Gather norm2.
114 ccv_nnc_cmd_t reduce_cmd = {
115 .cmd = CCV_NNC_CUSTOM_FORWARD,
116 .isa = &clip_grad_norm_reduce_norm2_vtab,
117 };
118 ccv_cnnp_model_parameter_gradients_map(model, parameters, reduce_cmd, ccv_nnc_no_hint, 0, 0, 0, norm2, parallel_count * 2, stream_context);
119 // Now compute max(max_norm / norm2, 1.0).
120 if (parallel_count > 1)
121 {
122 ccv_nnc_stream_context_t* streams[parallel_count];
123 ccv_nnc_stream_signal_t* signal;
124 if (stream_context)
125 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
126 for (i = 0; i < parallel_count; i++)
127 {
128 const int stream_type = CCV_TENSOR_GET_MEMORY(norm2[i * 2]->info.type)((norm2[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
129 const int device_id = CCV_TENSOR_GET_DEVICE_ID(norm2[i * 2]->info.type)(((norm2[i * 2]->info.type) & 0xfff00) >> 8);
130 int type = stream_type;
131 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
132 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
133 // Wait signal to finish.
134 if (stream_context)
135 ccv_nnc_stream_context_wait_signal(stream_0, signal);
136 ccv_nnc_cmd_exec(CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
137 ccv_nnc_cmd_exec(CMD_SET_FORWARD(max_norm)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={max_norm,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(max_normt[i])(ccv_nnc_tensor_t* []){max_normt[i]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
138 ccv_nnc_cmd_exec(CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(max_normt[i], norm2[i * 2])(ccv_nnc_tensor_t* []){max_normt[i], norm2[i * 2]}, (1 +1 +1 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1
), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
139 ccv_nnc_cmd_exec(CMD_CLAMP_FORWARD(NAN, 1)ccv_nnc_cmd(CCV_NNC_CLAMP_FORWARD, 0, (ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.clamp={.min=(__builtin_nanf ("")),.max=1
}}, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[i * 2])(ccv_nnc_tensor_t* []){norm2[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
140 if (stream_context)
141 {
142 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
143 ccv_nnc_stream_context_wait_signal(stream_context, signal);
144 }
145 streams[i] = stream_0;
146 }
147 // If this should be blocking, blocking it.
148 if (!stream_context)
149 for (i = 0; i < parallel_count; i++)
150 if (streams[i])
151 ccv_nnc_stream_context_wait(streams[i]);
152 } else {
153 ccv_nnc_cmd_exec(CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
154 ccv_nnc_cmd_exec(CMD_SET_FORWARD(max_norm)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={max_norm,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(max_normt[0])(ccv_nnc_tensor_t* []){max_normt[0]}, (1 +1 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
155 ccv_nnc_cmd_exec(CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(max_normt[0], norm2[0])(ccv_nnc_tensor_t* []){max_normt[0], norm2[0]}, (1 +1 +1 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
156 ccv_nnc_cmd_exec(CMD_CLAMP_FORWARD(NAN, 1)ccv_nnc_cmd(CCV_NNC_CLAMP_FORWARD, 0, (ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.clamp={.min=(__builtin_nanf ("")),.max=1
}}, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(norm2[0])(ccv_nnc_tensor_t* []){norm2[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
157 }
158 ccv_nnc_cmd_t scatter_cmd = {
159 .cmd = CCV_NNC_CUSTOM_FORWARD,
160 .isa = &clip_grad_norm_scatter_norm2_vtab,
161 };
162 ccv_cnnp_model_parameter_gradients_map(model, parameters, scatter_cmd, ccv_nnc_no_hint, 0, norm2, parallel_count * 2, 0, 0, stream_context);
163 if (stream_type == CCV_STREAM_CONTEXT_GPU)
164 for (i = 0; i < parallel_count; i++)
165 {
166 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, norm2[i * 2]->data.u8);
167 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, norm2[i * 2 + 1]->data.u8);
168 ccv_nnc_xpu_free(&compiled_data->xpu_alloc, max_normt[i]->data.u8);
169 }
170 for (i = 0; i < parallel_count; i++)
171 {
172 ccv_nnc_tensor_free(norm2[i * 2]);
173 ccv_nnc_tensor_free(norm2[i * 2 + 1]);
174 ccv_nnc_tensor_free(max_normt[i]);
175 }
176}
177
178// MARK - Add-on Functions
179
180static int _ccv_cnnp_model_isnan(const ccv_nnc_cmd_t cmd, const ccv_nnc_hint_t hint, const int flags, ccv_nnc_tensor_t* const* const inputs, const int input_size, ccv_nnc_tensor_t* const* const outputs, const int output_size, ccv_nnc_stream_context_t* const stream_context)
181{
182 const int device_id = CCV_TENSOR_GET_DEVICE_ID(inputs[0]->info.type)(((inputs[0]->info.type) & 0xfff00) >> 8);
183 ccv_nnc_tensor_t* const old_isnanr = outputs[1 + device_id * 2];
184 ccv_nnc_tensor_t* const isnanr = outputs[1 + device_id * 2 + 1];
185 ccv_nnc_cmd_t reduce_cmd = CMD_REDUCE_ISNAN_FORWARD()ccv_nnc_cmd(CCV_NNC_REDUCE_ISNAN_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1),.axis={}}}
), 0);
186 reduce_cmd.info.reduce.count = ccv_nnc_tensor_nd(inputs[0]->info.dim);
187 int i;
188 for (i = 0; i < cmd.info.reduce.count; i++)
189 reduce_cmd.info.reduce.axis[i] = i;
190 ccv_nnc_cmd_exec(reduce_cmd, hint, flags, TENSOR_LIST(inputs[0])(ccv_nnc_tensor_t* []){inputs[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(isnanr)(ccv_nnc_tensor_t* []){isnanr}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
191 ccv_nnc_cmd_exec(CMD_EWSUM_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSUM_FORWARD, 0, ccv_nnc_cmd_auto, 0), hint, flags, TENSOR_LIST(old_isnanr, isnanr)(ccv_nnc_tensor_t* []){old_isnanr, isnanr}, (1 +1 +1 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(old_isnanr)(ccv_nnc_tensor_t* []){old_isnanr}, (1 +1 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
192 return CCV_NNC_EXEC_SUCCESS;
193}
194
195static ccv_nnc_cmd_vtab_t reduce_isnan_vtab = {
196 .exec = _ccv_cnnp_model_isnan
197};
198
199int ccv_cnnp_model_parameter_gradients_isnan(ccv_cnnp_model_t* const model, const ccv_cnnp_model_io_t parameters, ccv_nnc_stream_context_t* const stream_context)
200{
201 ccv_cnnp_compiled_data_t* const compiled_data = model->compiled_data;
202 assert(compiled_data)((void) sizeof ((compiled_data) ? 1 : 0), __extension__ ({ if
(compiled_data) ; else __assert_fail ("compiled_data", "ccv_cnnp_model_addons.c"
, 202, __extension__ __PRETTY_FUNCTION__); }));
203 const int parallel_count = ccv_max(model->parallel_count, 1)({ typeof (model->parallel_count) _a = (model->parallel_count
); typeof (1) _b = (1); (_a > _b) ? _a : _b; });
204 ccv_nnc_tensor_t* isnanr[parallel_count * 2];
205 const int stream_type = model->compiled_data->stream_type;
206 int i;
207 if (stream_type == CCV_STREAM_CONTEXT_GPU)
208 {
209 for (i = 0; i < parallel_count; i++)
210 {
211 ccv_nnc_tensor_param_t info = {
212 .type = CCV_TENSOR_GPU_MEMORY,
213 .format = CCV_TENSOR_FORMAT_NHWC,
214 .datatype = CCV_32S,
215 .dim = {1},
216 };
217 CCV_TENSOR_SET_DEVICE_ID(info.type, i)(info.type) = (((info.type) & ~0xfff00) | (((i) & 0xfff
) << 8));
218 isnanr[i * 2] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
219 isnanr[i * 2 + 1] = ccv_nnc_tensor_new(ccv_nnc_xpu_alloc(&compiled_data->xpu_alloc, i, stream_context, ccv_nnc_tensor_data_size(info)), info, 0);
220 }
221 } else {
222 for (i = 0; i < parallel_count; i++)
223 {
224 ccv_nnc_tensor_param_t info = {
225 .type = CCV_TENSOR_CPU_MEMORY,
226 .format = CCV_TENSOR_FORMAT_NHWC,
227 .datatype = CCV_32S,
228 .dim = {1},
229 };
230 isnanr[i * 2] = ccv_nnc_tensor_new(0, info, 0);
231 isnanr[i * 2 + 1] = ccv_nnc_tensor_new(0, info, 0);
232 }
233 }
234 // zero out old isnanr.
235 if (parallel_count > 1)
236 {
237 ccv_nnc_stream_context_t* streams[parallel_count];
238 ccv_nnc_stream_signal_t* signal;
239 if (stream_context)
240 signal = ccv_nnc_stream_context_emit_signal_new(stream_context);
241 for (i = 0; i < parallel_count; i++)
242 {
243 const int stream_type = CCV_TENSOR_GET_MEMORY(isnanr[i * 2]->info.type)((isnanr[i * 2]->info.type) & 0x3) == CCV_TENSOR_GPU_MEMORY ? CCV_STREAM_CONTEXT_GPU : CCV_STREAM_CONTEXT_CPU;
244 const int device_id = CCV_TENSOR_GET_DEVICE_ID(isnanr[i * 2]->info.type)(((isnanr[i * 2]->info.type) & 0xfff00) >> 8);
245 int type = stream_type;
246 CCV_STREAM_SET_DEVICE_ID(type, device_id)(type) = (((type) & ~0xfff00) | (((device_id) & 0xfff
) << 8));
247 ccv_nnc_stream_context_t* const stream_0 = ccv_cnnp_compiled_data_get_stream(compiled_data, type);
248 // Wait signal to finish.
249 if (stream_context)
250 ccv_nnc_stream_context_wait_signal(stream_0, signal);
251 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(isnanr[i * 2])(ccv_nnc_tensor_t* []){isnanr[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_0);
252 if (stream_context)
253 {
254 ccv_nnc_stream_signal_t* const signal = ccv_nnc_stream_context_emit_signal_new(stream_0);
255 ccv_nnc_stream_context_wait_signal(stream_context, signal);
256 }
257 streams[i] = stream_0;
258 }
259 // If this should be blocking, blocking it.
260 if (!stream_context)
261 for (i = 0; i < parallel_count; i++)
262 if (streams[i])
263 ccv_nnc_stream_context_wait(streams[i]);
264 } else
265 ccv_nnc_cmd_exec(CMD_SET_FORWARD(0)ccv_nnc_cmd(CCV_NNC_SET_FORWARD, 0, (ccv_nnc_cmd_param_t){.size
={.dim={1,1,1}},.blas={.a={0,}}}, 0), ccv_nnc_no_hint, 0, 0, 0, TENSOR_LIST(isnanr[0])(ccv_nnc_tensor_t* []){isnanr[0]}, (1 +1 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), stream_context);
266 // Gather isnanr.
267 ccv_nnc_cmd_t reduce_cmd = {
268 .cmd = CCV_NNC_CUSTOM_FORWARD,
269 .isa = &reduce_isnan_vtab,
270 };
271 ccv_cnnp_model_parameter_gradients_map(model, parameters, reduce_cmd, ccv_nnc_no_hint, 0, 0, 0, isnanr, parallel_count * 2, stream_context);
272 for (i = 0; i < parallel_count; i++)
273 ccv_nnc_tensor_free(isnanr[i * 2 + 1]);
274 int retval = 0;
275 if (stream_type == CCV_TENSOR_GPU_MEMORY)
276 {
277 ccv_nnc_tensor_param_t info = {
278 .type = CCV_TENSOR_CPU_MEMORY,
279 .format = CCV_TENSOR_FORMAT_NHWC,
280 .datatype = CCV_32S,
281 .dim = {1},
282 };
283 ccv_nnc_tensor_t* checknan = ccv_nnc_tensor_new(0, info, 0);
284 for (i = 0; i < parallel_count; i++)
285 {
286 ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD()ccv_nnc_cmd(CCV_NNC_DATA_TRANSFER_FORWARD, 0, ccv_nnc_cmd_auto
, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(isnanr[i * 2])(ccv_nnc_tensor_t* []){isnanr[i * 2]}, (1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), TENSOR_LIST(checknan)(ccv_nnc_tensor_t* []){checknan}, (1 +1 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 -1), 0);
287 if (checknan->data.i32[0] > 0)
288 {
289 retval = 1;
290 break;
291 }
292 }
293 ccv_nnc_tensor_free(checknan);
294 } else {
295 for (i = 0; i < parallel_count; i++)
296 if (isnanr[i * 2]->data.i32[0] > 0)
297 {
298 retval = 1;
299 break;
300 }
301 }
302 for (i = 0; i < parallel_count; i++)
303 ccv_nnc_tensor_free(isnanr[i * 2]);
304 return retval;
305}
306
307// MARK - Core Layers
308
309static void _ccv_cnnp_sum_build(ccv_cnnp_model_t* const self, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
310{
311 PRINT(CCV_CLI_VERBOSE, "[cnnp_sum_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_sum_build] -\n"); fflush(stdout); } } while (
0);
312 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 312, __extension__ __PRETTY_FUNCTION__
); }));
313 outputs[0] = ccv_nnc_tensor_symbol_new(graph, ccv_nnc_tensor_symbol_params(graph, inputs[0]), 0);
314 ccv_nnc_graph_exec_symbol_new(graph, CMD_EWSUM_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSUM_FORWARD, 0, ccv_nnc_cmd_auto, 0), inputs, input_size, outputs, output_size, 0);
315}
316
317static ccv_cnnp_model_t* _ccv_cnnp_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
318
319static const ccv_cnnp_model_vtab_t ccv_cnnp_sum_isa = {
320 .build = _ccv_cnnp_sum_build,
321 .copy = _ccv_cnnp_sum_copy,
322};
323
324typedef struct {
325 ccv_cnnp_model_t super;
326 ccv_nnc_tensor_symbol_t output;
327} ccv_cnnp_model_sum_t;
328
329ccv_cnnp_model_t* ccv_cnnp_sum(const char* const name)
330{
331 ccv_cnnp_model_sum_t* const model_sum = (ccv_cnnp_model_sum_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sum_t));
332 model_sum->super.isa = &ccv_cnnp_sum_isa;
333 model_sum->super.input_size = 0;
334 model_sum->super.outputs = &model_sum->output;
335 model_sum->super.output_size = 1;
336 ccv_cnnp_model_copy_name(&model_sum->super, name);
337 return (ccv_cnnp_model_t*)model_sum;
338}
339
340static ccv_cnnp_model_t* _ccv_cnnp_sum_copy(const ccv_cnnp_model_t* const self, void* const context)
341{
342 return ccv_cnnp_sum(self->name);
343}
344
345typedef struct {
346 ccv_cnnp_model_t super;
347 int axis;
348 ccv_nnc_tensor_symbol_t output;
349} ccv_cnnp_model_concat_t;
350
351static void _ccv_cnnp_concat_build(ccv_cnnp_model_t* const super, ccv_nnc_symbolic_graph_t* const graph, const ccv_nnc_tensor_symbol_t* const inputs, const int input_size, ccv_nnc_tensor_symbol_t* const outputs, const int output_size)
352{
353 const ccv_cnnp_model_concat_t* const self = (const ccv_cnnp_model_concat_t*)super;
354 PRINT(CCV_CLI_VERBOSE, "[cnnp_concat_build] 1. -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_concat_build] 1. -\n"); fflush(stdout); } } while
(0);
355 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 355, __extension__ __PRETTY_FUNCTION__
); }));
356 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
357 int i, j;
358 if (output_params.dim[0] == 0)
359 for (i = 1; i < input_size; i++)
360 {
361 output_params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
362 if (output_params.dim[0] != 0)
363 break;
364 }
365 const int nd = ccv_nnc_tensor_nd(output_params.dim);
366 const int axis = self->axis;
367 if (nd > 0)
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__); }));
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++)
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)
404 {
405 ccv_nnc_tensor_symbol_t aliases[input_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_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
637 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
638 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], old_ofs, old_stride);
639 // We identify permute by checking if the stride is not in descending order.
640 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
641 const int nd = ccv_nnc_tensor_nd(params.dim);
642 const int new_nd = ccv_nnc_tensor_nd(dim);
643 int i, no_permute = 1;
644 // If the new dim has different nd, or we actually have a stride, we need to check if it is no permute or not.
645 if (new_nd != nd || (self->stride[0] != 0 && memcmp(self->stride, old_stride, sizeof(self->stride))))
646 for (i = 1; no_permute && i < nd; i++)
647 if (old_stride[i - 1] < old_stride[i])
648 no_permute = 0;
649 if (no_permute)
650 { // Just straightforward reshape if there is no no permute.
651 memcpy(params.dim, dim, sizeof(params.dim));
652 int* stride;
653 if (self->stride[0] == 0)
654 {
655 if (new_nd != nd) // Cannot use old stride.
656 {
657 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
658 stride = stride_from_dim;
659 } else
660 stride = old_stride;
661 } else
662 stride = self->stride;
663 if (self->format > 0)
664 params.format = self->format;
665 // tensor_symbol_alias_new flattens an alias to its root tensor. Preserve the
666 // parent view's starting position, expressing it in the new strides if needed.
667 const int* ofs = self->ofs;
668 int new_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
669 if (new_nd == nd && memcmp(stride, old_stride, sizeof(old_stride)) == 0)
670 {
671 for (i = 0; i < CCV_NNC_MAX_DIM_ALLOC(12); i++)
672 new_ofs[i] = old_ofs[i] + self->ofs[i];
673 ofs = new_ofs;
674 } else {
675 size_t offset = 0;
676 for (i = 0; i < nd; i++)
677 offset += (size_t)old_ofs[i] * old_stride[i];
678 memcpy(new_ofs, self->ofs, sizeof(new_ofs));
679 for (i = 0; i < new_nd; i++)
680 {
681 assert(stride[i] > 0)((void) sizeof ((stride[i] > 0) ? 1 : 0), __extension__ ({
if (stride[i] > 0) ; else __assert_fail ("stride[i] > 0"
, "ccv_cnnp_model_addons.c", 681, __extension__ __PRETTY_FUNCTION__
); }));
682 assert(offset / stride[i] <= INT_MAX - self->ofs[i])((void) sizeof ((offset / stride[i] <= 2147483647 - self->
ofs[i]) ? 1 : 0), __extension__ ({ if (offset / stride[i] <=
2147483647 - self->ofs[i]) ; else __assert_fail ("offset / stride[i] <= INT_MAX - self->ofs[i]"
, "ccv_cnnp_model_addons.c", 682, __extension__ __PRETTY_FUNCTION__
); }));
683 new_ofs[i] += (int)(offset / stride[i]);
684 offset %= stride[i];
685 }
686 // The caller must copy explicitly if the new strides cannot represent the offset.
687 assert(offset == 0)((void) sizeof ((offset == 0) ? 1 : 0), __extension__ ({ if (
offset == 0) ; else __assert_fail ("offset == 0", "ccv_cnnp_model_addons.c"
, 687, __extension__ __PRETTY_FUNCTION__); }));
688 ofs = new_ofs;
689 }
690 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, params, 0);
691 } else {
692 // Otherwise, we first do format transform to plain tensor and then do reshape.
693 ccv_nnc_tensor_symbol_t permuted = ccv_nnc_tensor_symbol_new(graph, params, 0);
694 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");
695 memcpy(params.dim, dim, sizeof(params.dim));
696 int* stride;
697 if (self->stride[0] == 0)
698 {
699 ccv_nnc_tensor_get_stride(dim, stride_from_dim);
700 stride = stride_from_dim;
701 } else
702 stride = self->stride;
703 if (self->format > 0)
704 params.format = self->format;
705 // And then we create alias against the permuted one.
706 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, permuted, self->ofs, stride, params, 0);
707 }
708 }
709}
710
711static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context);
712
713static const ccv_cnnp_model_vtab_t ccv_cnnp_reshape_isa = {
714 .build = _ccv_cnnp_reshape_build,
715 .copy = _ccv_cnnp_reshape_copy,
716};
717
718ccv_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)
719{
720 ccv_cnnp_model_reshape_t* const model_reshape = (ccv_cnnp_model_reshape_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_reshape_t));
721 model_reshape->super.isa = &ccv_cnnp_reshape_isa;
722 model_reshape->super.input_size = 1;
723 model_reshape->super.outputs = &model_reshape->output;
724 model_reshape->super.output_size = 1;
725 ccv_cnnp_model_copy_name(&model_reshape->super, name);
726 model_reshape->format = format;
727 memcpy(model_reshape->dim, dim, sizeof(model_reshape->dim));
728 memcpy(model_reshape->ofs, ofs, sizeof(model_reshape->ofs));
729 if (stride[0] != 0)
730 memcpy(model_reshape->stride, stride, sizeof(model_reshape->stride));
731 return (ccv_cnnp_model_t*)model_reshape;
732}
733
734static ccv_cnnp_model_t* _ccv_cnnp_reshape_copy(const ccv_cnnp_model_t* const super, void* const context)
735{
736 const ccv_cnnp_model_reshape_t* const self = (const ccv_cnnp_model_reshape_t*)super;
737 return ccv_cnnp_reshape(self->format, self->dim, self->ofs, self->stride, self->super.name);
738}
739
740typedef struct {
741 ccv_cnnp_model_t super;
742 ccv_nnc_tensor_symbol_t output;
743 int type;
744 int begin[CCV_NNC_MAX_DIM_ALLOC(12)];
745 int end[CCV_NNC_MAX_DIM_ALLOC(12)];
746} ccv_cnnp_model_pad_t;
747
748static 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)
749{
750 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"
, 750, __extension__ __PRETTY_FUNCTION__); }));
751 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", 751, __extension__ __PRETTY_FUNCTION__
); }));
752 ccv_cnnp_model_pad_t* const self = (ccv_cnnp_model_pad_t*)super;
753 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);
754 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
755 const int nd = ccv_nnc_tensor_nd(input_params.dim);
756 ccv_nnc_tensor_param_t params = input_params;
757 int i;
758 for (i = 0 ; i < nd; i++)
759 params.dim[i] += self->begin[i] + self->end[i];
760 const ccv_nnc_tensor_symbol_t padded = ccv_nnc_tensor_symbol_new(graph, params, 0);
761 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);
762 memcpy(pad.info.size.dim, self->begin, sizeof(pad.info.size.dim));
763 memcpy(pad.info.pad.end, self->end, sizeof(pad.info.pad.end));
764 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");
765 outputs[0] = padded;
766}
767
768static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context);
769
770static const ccv_cnnp_model_vtab_t ccv_cnnp_pad_isa = {
771 .build = _ccv_cnnp_pad_build,
772 .copy = _ccv_cnnp_pad_copy,
773};
774
775ccv_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)
776{
777 ccv_cnnp_model_pad_t* const model_pad = (ccv_cnnp_model_pad_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pad_t));
778 model_pad->super.isa = &ccv_cnnp_pad_isa;
779 model_pad->super.input_size = 1;
780 model_pad->super.outputs = &model_pad->output;
781 model_pad->super.output_size = 1;
782 ccv_cnnp_model_copy_name(&model_pad->super, name);
783 model_pad->type = type;
784 memcpy(model_pad->begin, begin, sizeof(model_pad->begin));
785 memcpy(model_pad->end, end, sizeof(model_pad->end));
786 return (ccv_cnnp_model_t*)model_pad;
787}
788
789static ccv_cnnp_model_t* _ccv_cnnp_pad_copy(const ccv_cnnp_model_t* const super, void* const context)
790{
791 const ccv_cnnp_model_pad_t* const self = (const ccv_cnnp_model_pad_t*)super;
792 return ccv_cnnp_pad(self->type, self->begin, self->end, self->super.name);
793}
794
795typedef struct {
796 ccv_cnnp_model_t super;
797 ccv_nnc_tensor_symbol_t output;
798} ccv_cnnp_model_identity_t;
799
800static 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)
801{
802 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"
, 802, __extension__ __PRETTY_FUNCTION__); }));
803 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", 803, __extension__ __PRETTY_FUNCTION__
); }));
804 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);
805 outputs[0] = inputs[0];
806}
807
808static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context);
809
810static const ccv_cnnp_model_vtab_t ccv_cnnp_identity_isa = {
811 .build = _ccv_cnnp_identity_build,
812 .copy = _ccv_cnnp_identity_copy,
813};
814
815ccv_cnnp_model_t* ccv_cnnp_identity(const char* const name)
816{
817 ccv_cnnp_model_identity_t* const model_identity = (ccv_cnnp_model_identity_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_identity_t));
818 model_identity->super.isa = &ccv_cnnp_identity_isa;
819 model_identity->super.input_size = 1;
820 model_identity->super.outputs = &model_identity->output;
821 model_identity->super.output_size = 1;
822 ccv_cnnp_model_copy_name(&model_identity->super, name);
823 return (ccv_cnnp_model_t*)model_identity;
824}
825
826static ccv_cnnp_model_t* _ccv_cnnp_identity_copy(const ccv_cnnp_model_t* const super, void* const context)
827{
828 const ccv_cnnp_model_identity_t* const self = (const ccv_cnnp_model_identity_t*)super;
829 return ccv_cnnp_identity(self->super.name);
830}
831
832typedef struct {
833 ccv_cnnp_model_t super;
834 ccv_nnc_tensor_symbol_t output;
835 int index[CCV_NNC_MAX_DIM_ALLOC(12)];
836} ccv_cnnp_model_permute_t;
837
838static 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)
839{
840 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"
, 840, __extension__ __PRETTY_FUNCTION__); }));
841 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", 841, __extension__ __PRETTY_FUNCTION__
); }));
842 ccv_cnnp_model_permute_t* const self = (ccv_cnnp_model_permute_t*)super;
843 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);
844 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
845 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
846 const int nd = ccv_nnc_tensor_nd(params.dim);
847 int input_dim[CCV_NNC_MAX_DIM_ALLOC(12)];
848 memcpy(input_dim, params.dim, sizeof(params.dim));
849 int input_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
850 int output_stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
851 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If it is not an alias. Find stride and permute.
852 {
853 ccv_nnc_tensor_get_stride(input_dim, input_stride);
854 int i;
855 for (i = 0; i < nd; i++)
856 {
857 const int idx = self->index[i];
858 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"
, 858, __extension__ __PRETTY_FUNCTION__); }));
859 params.dim[i] = input_dim[idx];
860 output_stride[i] = input_stride[idx];
861 }
862 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ccv_nnc_no_ofs, output_stride, params, 0);
863 } else {
864 // if it is an alias, we can get the stride from it and use that.
865 int input_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
866 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], input_ofs, input_stride);
867 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", 867, __extension__ __PRETTY_FUNCTION__
); }));
868 int output_ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
869 int i;
870 for (i = 0; i < nd; i++)
871 {
872 const int idx = self->index[i];
873 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"
, 873, __extension__ __PRETTY_FUNCTION__); }));
874 params.dim[i] = input_dim[idx];
875 output_stride[i] = input_stride[idx];
876 output_ofs[i] = input_ofs[idx];
877 }
878 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], output_ofs, output_stride, params, 0);
879 }
880}
881
882static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context);
883
884static const ccv_cnnp_model_vtab_t ccv_cnnp_permute_isa = {
885 .build = _ccv_cnnp_permute_build,
886 .copy = _ccv_cnnp_permute_copy,
887};
888
889ccv_cnnp_model_t* ccv_cnnp_permute(const int index[CCV_NNC_MAX_DIM_ALLOC(12)], const char* const name)
890{
891 ccv_cnnp_model_permute_t* const model_permute = (ccv_cnnp_model_permute_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_permute_t));
892 model_permute->super.isa = &ccv_cnnp_permute_isa;
893 model_permute->super.input_size = 1;
894 model_permute->super.outputs = &model_permute->output;
895 model_permute->super.output_size = 1;
896 ccv_cnnp_model_copy_name(&model_permute->super, name);
897 memcpy(model_permute->index, index, sizeof(model_permute->index));
898 return (ccv_cnnp_model_t*)model_permute;
899}
900
901static ccv_cnnp_model_t* _ccv_cnnp_permute_copy(const ccv_cnnp_model_t* const super, void* const context)
902{
903 const ccv_cnnp_model_permute_t* const self = (const ccv_cnnp_model_permute_t*)super;
904 return ccv_cnnp_permute(self->index, self->super.name);
905}
906
907typedef struct {
908 ccv_cnnp_model_t super;
909 int index;
910 ccv_nnc_tensor_symbol_t output;
911} ccv_cnnp_model_extract_t;
912
913static 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)
914{
915 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 915, __extension__ __PRETTY_FUNCTION__
); }));
916 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
917 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);
918 outputs[0] = inputs[self->index];
919}
920
921static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const self, void* const context);
922
923static const ccv_cnnp_model_vtab_t ccv_cnnp_extract_isa = {
924 .build = _ccv_cnnp_extract_build,
925 .copy = _ccv_cnnp_extract_copy,
926};
927
928ccv_cnnp_model_t* ccv_cnnp_extract(const int index, const char* const name)
929{
930 ccv_cnnp_model_extract_t* const model_extract = (ccv_cnnp_model_extract_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_extract_t));
931 model_extract->index = index;
932 model_extract->super.isa = &ccv_cnnp_extract_isa;
933 model_extract->super.input_size = 0;
934 model_extract->super.outputs = &model_extract->output;
935 model_extract->super.output_size = 1;
936 ccv_cnnp_model_copy_name(&model_extract->super, name);
937 return (ccv_cnnp_model_t*)model_extract;
938}
939
940static ccv_cnnp_model_t* _ccv_cnnp_extract_copy(const ccv_cnnp_model_t* const super, void* const context)
941{
942 ccv_cnnp_model_extract_t* const self = (ccv_cnnp_model_extract_t*)super;
943 return ccv_cnnp_extract(self->index, self->super.name);
944}
945
946typedef struct {
947 ccv_cnnp_model_t super;
948 ccv_nnc_tensor_symbol_t output;
949} ccv_cnnp_model_flatten_t;
950
951static 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)
952{
953 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);
954 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"
, 954, __extension__ __PRETTY_FUNCTION__); }));
955 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", 955, __extension__ __PRETTY_FUNCTION__
); }));
956 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
957 ccv_nnc_tensor_param_t output_params = params;
958 memset(output_params.dim, 0, sizeof(output_params.dim));
959 output_params.dim[0] = ccv_nnc_tensor_get_n(params);
960 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", 960, __extension__ __PRETTY_FUNCTION__
); }));
961 output_params.dim[1] = ccv_nnc_tensor_count(params) / output_params.dim[0];
962 int stride[CCV_NNC_MAX_DIM_ALLOC(12)] = {};
963 ccv_nnc_tensor_get_stride(output_params.dim, stride);
964 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], DIM_ALLOC()(int [(12)]){}, stride, output_params, 0);
965}
966
967static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context);
968
969static const ccv_cnnp_model_vtab_t ccv_cnnp_flatten_isa = {
970 .build = _ccv_cnnp_flatten_build,
971 .copy = _ccv_cnnp_flatten_copy,
972};
973
974ccv_cnnp_model_t* ccv_cnnp_flatten(const char* const name)
975{
976 ccv_cnnp_model_flatten_t* const model_flatten = (ccv_cnnp_model_flatten_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_flatten_t));
977 model_flatten->super.isa = &ccv_cnnp_flatten_isa;
978 model_flatten->super.input_size = 1;
979 model_flatten->super.outputs = &model_flatten->output;
980 model_flatten->super.output_size = 1;
981 ccv_cnnp_model_copy_name(&model_flatten->super, name);
982 return (ccv_cnnp_model_t*)model_flatten;
983}
984
985static ccv_cnnp_model_t* _ccv_cnnp_flatten_copy(const ccv_cnnp_model_t* const self, void* const context)
986{
987 return ccv_cnnp_flatten(self->name);
988}
989
990// MARK - Batch Norm Layer
991
992typedef struct {
993 ccv_cnnp_model_t super;
994 ccv_nnc_tensor_symbol_t output;
995 ccv_nnc_tensor_symbol_t bias;
996 ccv_nnc_tensor_symbol_t scale;
997 ccv_nnc_graph_exec_symbol_t batch_norm;
998 ccv_nnc_cmd_param_t params;
999 ccv_array_t* zero_inits;
1000 ccv_array_t* retainables;
1001} ccv_cnnp_model_batch_norm_t;
1002
1003static 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)
1004{
1005 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"
, 1005, __extension__ __PRETTY_FUNCTION__); }));
1006 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", 1006, __extension__ __PRETTY_FUNCTION__
); }));
1007 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1008 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);
1009 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1010 const int nd = ccv_nnc_tensor_nd(params.dim);
1011 ccv_nnc_tensor_param_t bias_params = params;
1012 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1013 // If the accuracy is not enough, bump it to 32-bit floating point.
1014 if (bias_params.datatype != CCV_32F && bias_params.datatype != CCV_64F)
1015 bias_params.datatype = CCV_32F;
1016 bias_params.dim[0] = nd > 1 ? ccv_nnc_tensor_get_c(params) : params.dim[0];
1017 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, params, 0);
1018 // Both scale and bias are shared between if this model is reused.
1019 if (!self->scale.graph)
1020 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
1021 if (!self->bias.graph)
1022 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1023 const ccv_nnc_tensor_symbol_t scale = ccv_cnnp_model_get_symbol(super, self->scale);
1024 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1025 const ccv_nnc_tensor_symbol_t mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "mean");
1026 const ccv_nnc_tensor_symbol_t var = ccv_nnc_tensor_symbol_new(graph, bias_params, "var");
1027 // Otherwise, notice mean, var, saved_mean, saved_inv_std are not reused.
1028 if (!self->zero_inits)
1029 self->zero_inits = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
1030 ccv_array_push(self->zero_inits, &mean);
1031 ccv_array_push(self->zero_inits, &var);
1032 const ccv_nnc_tensor_symbol_t out_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_mean");
1033 const ccv_nnc_tensor_symbol_t out_var = ccv_nnc_tensor_symbol_new(graph, bias_params, "out_var");
1034 if (!self->retainables)
1035 self->retainables = ccv_array_new(sizeof(ccv_nnc_tensor_symbol_t), 0, 0);
1036 ccv_array_push(self->retainables, &out_mean);
1037 ccv_array_push(self->retainables, &out_var);
1038 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_mean");
1039 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, bias_params, "saved_inv_std");
1040 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1041 ccv_nnc_cmd_param_t batch_norm = self->params;
1042 batch_norm.bnorm.count = hw >= 0 ? CCV_NNC_MAX_DIM(2) + 1 : 1;
1043 int i;
1044 batch_norm.bnorm.axis[0] = (params.format == CCV_TENSOR_FORMAT_CHWN) ? 3 : 0;
1045 if (hw >= 0)
1046 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1047 batch_norm.bnorm.axis[i + 1] = i + hw;
1048 self->params = batch_norm;
1049 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");
1050 outputs[0] = output;
1051}
1052
1053static 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)
1054{
1055 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1056 if (self->scale.graph)
1057 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);
1058 if (self->bias.graph)
1059 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);
1060 int i;
1061 if (self->zero_inits)
1062 for (i = 0; i < self->zero_inits->rnum; i++)
1063 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))));
1064}
1065
1066static 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)
1067{
1068 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1069 if (self->scale.graph)
1070 add_to_array(parameters, self->scale, is_trainable);
1071 if (self->bias.graph)
1072 add_to_array(parameters, self->bias, is_trainable);
1073}
1074
1075static 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)
1076{
1077 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1078 int i;
1079 if (self->retainables)
1080 for (i = 0; i < self->retainables->rnum; i++)
1081 {
1082 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)));
1083 add_to_array(outputs, symbol, 0);
1084 }
1085}
1086
1087static 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)
1088{
1089 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1090 if (self->batch_norm.graph)
1091 {
1092 self->params.bnorm.is_test = is_test;
1093 updater(context, self->batch_norm, ccv_nnc_cmd(CCV_NNC_BATCH_NORM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
1094 }
1095}
1096
1097static void _ccv_cnnp_batch_norm_deinit(ccv_cnnp_model_t* const super)
1098{
1099 ccv_cnnp_model_batch_norm_t* const self = (ccv_cnnp_model_batch_norm_t*)super;
1100 if (self->zero_inits)
1101 ccv_array_free(self->zero_inits);
1102 if (self->retainables)
1103 ccv_array_free(self->retainables);
1104}
1105
1106static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
1107
1108static const ccv_cnnp_model_vtab_t ccv_cnnp_batch_norm_isa = {
1109 .build = _ccv_cnnp_batch_norm_build,
1110 .init_states = _ccv_cnnp_batch_norm_init_states,
1111 .add_to_parameter = _ccv_cnnp_batch_norm_add_to_parameter,
1112 .add_to_output = _ccv_cnnp_batch_norm_add_to_output,
1113 .copy = _ccv_cnnp_batch_norm_copy,
1114 .set_is_test = _ccv_cnnp_batch_norm_set_is_test,
1115 .deinit = _ccv_cnnp_batch_norm_deinit,
1116};
1117
1118ccv_cnnp_model_t* ccv_cnnp_batch_norm(const float momentum, const float epsilon, const int is_trainable, const char* const name)
1119{
1120 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));
1121 model_batch_norm->super.isa = &ccv_cnnp_batch_norm_isa;
1122 model_batch_norm->super.input_size = 1;
1123 model_batch_norm->super.outputs = &model_batch_norm->output;
1124 model_batch_norm->super.output_size = 1;
1125 model_batch_norm->super.is_trainable = is_trainable;
1126 ccv_cnnp_model_copy_name(&model_batch_norm->super, name);
1127 model_batch_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
1128 model_batch_norm->scale.graph = 0;
1129 model_batch_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1130 model_batch_norm->bias.graph = 0;
1131 model_batch_norm->params.bnorm.momentum = momentum;
1132 model_batch_norm->params.bnorm.epsilon = epsilon;
1133 return (ccv_cnnp_model_t*)model_batch_norm;
1134}
1135
1136static ccv_cnnp_model_t* _ccv_cnnp_batch_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
1137{
1138 const ccv_cnnp_model_batch_norm_t* const self = (const ccv_cnnp_model_batch_norm_t*)super;
1139 return ccv_cnnp_batch_norm(self->params.bnorm.momentum, self->params.bnorm.epsilon, self->super.is_trainable, self->super.name);
1140}
1141
1142// MARK - Convolution Layer
1143
1144typedef struct {
1145 ccv_cnnp_model_t super;
1146 ccv_nnc_tensor_symbol_t output;
1147 ccv_nnc_tensor_symbol_t weights;
1148 ccv_nnc_tensor_symbol_t bias;
1149 int groups;
1150 int filters;
1151 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1152 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1153 int no_bias;
1154 int format;
1155 ccv_nnc_hint_t hint;
1156} ccv_cnnp_model_convolution_t;
1157
1158static 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)
1159{
1160 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1161 PRINT(CCV_CLI_VERBOSE, "[cnnp_convolution_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_convolution_build] -\n"); fflush(stdout); } }
while (0);
1
Assuming the condition is false
→
2
←
Taking false branch
→
3
←
Loop condition is false. Exiting loop
→
1162 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"
, 1162, __extension__ __PRETTY_FUNCTION__); }));
4
←
Assuming 'input_size' is equal to 1
→
5
←
Taking true branch
→
1163 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", 1163, __extension__ __PRETTY_FUNCTION__
); }));
6
←
Assuming 'output_size' is equal to 1
→
7
←
Taking true branch
→
1164 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1165 int i;
1166 const int k_nd = ccv_nnc_tensor_nd(self->kdim);
1167 const int nd = k_nd + 2;
1168 ccv_nnc_tensor_param_t weights_params = params;
1169 if (self->format)
8
←
Assuming field 'format' is 0
→
9
←
Taking false branch
→
1170 weights_params.format = self->format;
1171 ccv_nnc_tensor_set_n(&weights_params, self->filters);
1172 const int a_nd = ccv_nnc_tensor_nd(params.dim);
1173 int c;
10
←
'c' declared without an initial value
→
1174 switch (params.format)
11
←
'Default' branch taken. Execution continues on line 1189
→
1175 {
1176 case CCV_TENSOR_FORMAT_NHWC:
1177 c = params.dim[a_nd - 1];
1178 break;
1179 case CCV_TENSOR_FORMAT_NCHW:
1180 if (a_nd == k_nd + 1)
1181 c = params.dim[0];
1182 else
1183 c = params.dim[a_nd <= 1 ? 0 : 1];
1184 break;
1185 case CCV_TENSOR_FORMAT_CHWN:
1186 c = params.dim[0];
1187 break;
1188 }
1189 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", 1189, __extension__ __PRETTY_FUNCTION__
); }));
12
←
The left operand of '%' is a garbage value
1190 ccv_nnc_tensor_set_c(&weights_params, nd, c / self->groups);
1191 int hw = -1;
1192 if (weights_params.format == CCV_TENSOR_FORMAT_NHWC || weights_params.format == CCV_TENSOR_FORMAT_CHWN)
1193 hw = 1;
1194 else if (weights_params.format == CCV_TENSOR_FORMAT_NCHW)
1195 hw = 2;
1196 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1196, __extension__ __PRETTY_FUNCTION__); }));
1197 for (i = 0; i < k_nd; i++)
1198 weights_params.dim[i + hw] = self->kdim[i];
1199 if (!self->weights.graph)
1200 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1201 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"
, 1201, __extension__ __PRETTY_FUNCTION__); }));
1202 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1203 ccv_nnc_tensor_param_t bias_params = params;
1204 if (self->format)
1205 bias_params.format = self->format;
1206 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1207 bias_params.dim[0] = self->filters;
1208 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);
1209 for (i = 0; i < k_nd; i++)
1210 cmd.info.size.dim[i] = self->kdim[i];
1211 cmd.info.size.dim[k_nd] = c;
1212 memcpy(cmd.info.convolution.dilation, self->dilation, sizeof(self->dilation));
1213 ccv_nnc_tensor_param_t output_params;
1214 // Dilate weight size based on the dilation factor.
1215 for (i = 0; i < k_nd; i++)
1216 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;
1217 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1218 params,
1219 weights_params,
1220 bias_params,
1221 }, 3, self->hint, &output_params, 1);
1222 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1223 ccv_nnc_graph_exec_symbol_t convolution;
1224 if (self->no_bias)
1225 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");
1226 else {
1227 if (!self->bias.graph)
1228 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1229 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1230 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");
1231 }
1232 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution, self->hint);
1233 outputs[0] = output;
1234}
1235
1236static 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)
1237{
1238 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1239 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1240 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
; });
1241 const int count = ccv_nnc_tensor_count(weight_params);
1242 const float std = sqrtf(2) / sqrtf(count / n);
1243 const float bound = sqrtf(3) * std;
1244 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);
1245 if (self->bias.graph)
1246 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);
1247}
1248
1249static 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)
1250{
1251 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1252 add_to_array(parameters, self->weights, is_trainable);
1253 if (self->bias.graph)
1254 add_to_array(parameters, self->bias, is_trainable);
1255}
1256
1257static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context);
1258
1259static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_isa = {
1260 .build = _ccv_cnnp_convolution_build,
1261 .init_states = _ccv_cnnp_convolution_init_states,
1262 .add_to_parameter = _ccv_cnnp_convolution_add_to_parameter,
1263 .copy = _ccv_cnnp_convolution_copy,
1264};
1265
1266ccv_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)
1267{
1268 ccv_cnnp_model_convolution_t* const model_convolution = (ccv_cnnp_model_convolution_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_convolution_t));
1269 model_convolution->super.isa = &ccv_cnnp_convolution_isa;
1270 model_convolution->super.input_size = 1;
1271 model_convolution->super.outputs = &model_convolution->output;
1272 model_convolution->super.output_size = 1;
1273 model_convolution->super.is_trainable = is_trainable;
1274 ccv_cnnp_model_copy_name(&model_convolution->super, name);
1275 model_convolution->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1276 model_convolution->weights.graph = 0;
1277 model_convolution->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1278 model_convolution->bias.graph = 0;
1279 model_convolution->groups = groups;
1280 model_convolution->filters = filters;
1281 memcpy(model_convolution->kdim, kdim, sizeof(model_convolution->kdim));
1282 memcpy(model_convolution->dilation, dilation, sizeof(model_convolution->dilation));
1283 model_convolution->no_bias = no_bias;
1284 model_convolution->hint = hint;
1285 model_convolution->format = format;
1286 return (ccv_cnnp_model_t*)model_convolution;
1287}
1288
1289static ccv_cnnp_model_t* _ccv_cnnp_convolution_copy(const ccv_cnnp_model_t* const super, void* const context)
1290{
1291 ccv_cnnp_model_convolution_t* const self = (ccv_cnnp_model_convolution_t*)super;
1292 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);
1293}
1294
1295// MARK - Convolution Transpose Layer
1296
1297typedef struct {
1298 ccv_cnnp_model_t super;
1299 ccv_nnc_tensor_symbol_t output;
1300 ccv_nnc_tensor_symbol_t weights;
1301 ccv_nnc_tensor_symbol_t bias;
1302 int groups;
1303 int filters;
1304 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1305 int dilation[CCV_NNC_MAX_DIM_ALLOC(12)];
1306 int output_padding;
1307 int no_bias;
1308 int format;
1309 ccv_nnc_hint_t hint;
1310} ccv_cnnp_model_convolution_transpose_t;
1311
1312static 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)
1313{
1314 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1315 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);
1316 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"
, 1316, __extension__ __PRETTY_FUNCTION__); }));
1317 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", 1317, __extension__ __PRETTY_FUNCTION__
); }));
1318 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1319 int i;
1320 const int nd = CCV_NNC_MAX_DIM(2) + 2;
1321 ccv_nnc_tensor_param_t weights_params = params;
1322 if (self->format)
1323 weights_params.format = self->format;
1324 const int c = ccv_nnc_tensor_get_c(params);
1325 ccv_nnc_tensor_set_n(&weights_params, c);
1326 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", 1326, __extension__ __PRETTY_FUNCTION__
); }));
1327 ccv_nnc_tensor_set_c(&weights_params, nd, self->filters / self->groups);
1328 const int hw = ccv_nnc_tensor_hw(weights_params, nd, CCV_NNC_MAX_DIM(2));
1329 assert(hw >= 0)((void) sizeof ((hw >= 0) ? 1 : 0), __extension__ ({ if (hw
>= 0) ; else __assert_fail ("hw >= 0", "ccv_cnnp_model_addons.c"
, 1329, __extension__ __PRETTY_FUNCTION__); }));
1330 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1331 weights_params.dim[i + hw] = self->kdim[i];
1332 if (!self->weights.graph)
1333 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1334 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"
, 1334, __extension__ __PRETTY_FUNCTION__); }));
1335 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1336 ccv_nnc_tensor_param_t bias_params = params;
1337 if (self->format)
1338 bias_params.format = self->format;
1339 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1340 bias_params.dim[0] = self->filters;
1341 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);
1342 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1343 cmd.info.size.dim[i] = self->kdim[i];
1344 cmd.info.size.dim[CCV_NNC_MAX_DIM(2)] = c;
1345 memcpy(cmd.info.convolution_transpose.dilation, self->dilation, sizeof(self->dilation));
1346 ccv_nnc_tensor_param_t output_params;
1347 // Dilate weight size based on the dilation factor.
1348 for (i = 0; i < CCV_NNC_MAX_DIM(2); i++)
1349 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;
1350 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1351 params,
1352 weights_params,
1353 bias_params,
1354 }, 3, self->hint, &output_params, 1);
1355 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1356 ccv_nnc_graph_exec_symbol_t convolution_transpose;
1357 if (self->no_bias)
1358 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");
1359 else {
1360 if (!self->bias.graph)
1361 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1362 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1363 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");
1364 }
1365 ccv_nnc_graph_exec_symbol_set_hint(graph, convolution_transpose, self->hint);
1366 outputs[0] = output;
1367}
1368
1369static 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)
1370{
1371 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1372 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1373 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
; });
1374 const int count = ccv_nnc_tensor_count(weight_params);
1375 const float std = sqrtf(2) / sqrtf(count / n);
1376 const float bound = sqrtf(3) * std;
1377 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);
1378 if (self->bias.graph)
1379 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);
1380}
1381
1382static 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)
1383{
1384 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1385 add_to_array(parameters, self->weights, is_trainable);
1386 if (self->bias.graph)
1387 add_to_array(parameters, self->bias, is_trainable);
1388}
1389
1390static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
1391
1392static const ccv_cnnp_model_vtab_t ccv_cnnp_convolution_transpose_isa = {
1393 .build = _ccv_cnnp_convolution_transpose_build,
1394 .init_states = _ccv_cnnp_convolution_transpose_init_states,
1395 .add_to_parameter = _ccv_cnnp_convolution_transpose_add_to_parameter,
1396 .copy = _ccv_cnnp_convolution_transpose_copy,
1397};
1398
1399ccv_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)
1400{
1401 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));
1402 model_convolution_transpose->super.isa = &ccv_cnnp_convolution_transpose_isa;
1403 model_convolution_transpose->super.input_size = 1;
1404 model_convolution_transpose->super.outputs = &model_convolution_transpose->output;
1405 model_convolution_transpose->super.output_size = 1;
1406 model_convolution_transpose->super.is_trainable = is_trainable;
1407 ccv_cnnp_model_copy_name(&model_convolution_transpose->super, name);
1408 model_convolution_transpose->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1409 model_convolution_transpose->weights.graph = 0;
1410 model_convolution_transpose->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1411 model_convolution_transpose->bias.graph = 0;
1412 model_convolution_transpose->groups = groups;
1413 model_convolution_transpose->filters = filters;
1414 memcpy(model_convolution_transpose->kdim, kdim, sizeof(model_convolution_transpose->kdim));
1415 memcpy(model_convolution_transpose->dilation, dilation, sizeof(model_convolution_transpose->dilation));
1416 model_convolution_transpose->output_padding = output_padding;
1417 model_convolution_transpose->no_bias = no_bias;
1418 model_convolution_transpose->hint = hint;
1419 model_convolution_transpose->format = format;
1420 return (ccv_cnnp_model_t*)model_convolution_transpose;
1421}
1422
1423static ccv_cnnp_model_t* _ccv_cnnp_convolution_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
1424{
1425 ccv_cnnp_model_convolution_transpose_t* const self = (ccv_cnnp_model_convolution_transpose_t*)super;
1426 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);
1427}
1428
1429// MARK - Dense Layer
1430
1431typedef struct {
1432 ccv_cnnp_model_t super;
1433 ccv_nnc_tensor_symbol_t output;
1434 ccv_nnc_tensor_symbol_t weights;
1435 ccv_nnc_tensor_symbol_t bias;
1436 int count;
1437 int no_bias;
1438 int flags;
1439} ccv_cnnp_model_dense_t;
1440
1441static 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)
1442{
1443 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1444 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);
1445 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"
, 1445, __extension__ __PRETTY_FUNCTION__); }));
1446 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", 1446, __extension__ __PRETTY_FUNCTION__
); }));
1447 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1448 ccv_nnc_tensor_param_t weights_params = params;
1449 memset(weights_params.dim, 0, sizeof(weights_params.dim));
1450 if (params.dim[0] != 0)
1451 {
1452 weights_params.dim[0] = self->count;
1453 weights_params.dim[1] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
1454 }
1455 if (!self->weights.graph)
1456 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
1457 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"
, 1457, __extension__ __PRETTY_FUNCTION__); }));
1458 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
1459 ccv_nnc_tensor_param_t bias_params = params;
1460 memset(bias_params.dim, 0, sizeof(bias_params.dim));
1461 bias_params.dim[0] = self->count;
1462 ccv_nnc_cmd_t cmd = {0};
1463 cmd.cmd = CCV_NNC_GEMM_FORWARD;
1464 cmd.info.blas.a[0] = 1;
1465 cmd.info.blas.a[1] = 1;
1466 cmd.info.blas.transpose_b[0] = 0;
1467 cmd.info.blas.transpose_b[1] = 1;
1468 cmd.info.blas.flags = self->flags;
1469 ccv_nnc_tensor_param_t output_params;
1470 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
1471 params,
1472 weights_params,
1473 bias_params,
1474 }, 3, ccv_nnc_no_hint, &output_params, 1);
1475 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1476 if (self->no_bias)
1477 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");
1478 else {
1479 if (!self->bias.graph)
1480 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
1481 const ccv_nnc_tensor_symbol_t bias = ccv_cnnp_model_get_symbol(super, self->bias);
1482 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");
1483 }
1484 outputs[0] = output;
1485}
1486
1487static 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)
1488{
1489 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1490 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
1491 const int c = weight_params.dim[1];
1492 const float std = sqrtf(2) / sqrtf(c);
1493 const float bound = sqrtf(3) * std;
1494 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);
1495 if (self->bias.graph)
1496 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);
1497}
1498
1499static 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)
1500{
1501 ccv_cnnp_model_dense_t* const self = (ccv_cnnp_model_dense_t*)super;
1502 add_to_array(parameters, self->weights, is_trainable);
1503 if (self->bias.graph)
1504 add_to_array(parameters, self->bias, is_trainable);
1505}
1506
1507static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
1508
1509static const ccv_cnnp_model_vtab_t ccv_cnnp_dense_isa = {
1510 .build = _ccv_cnnp_dense_build,
1511 .init_states = _ccv_cnnp_dense_init_states,
1512 .add_to_parameter = _ccv_cnnp_dense_add_to_parameter,
1513 .copy = _ccv_cnnp_dense_copy,
1514};
1515
1516ccv_cnnp_model_t* ccv_cnnp_dense(const int count, const int no_bias, const int flags, const int is_trainable, const char* const name)
1517{
1518 ccv_cnnp_model_dense_t* const model_dense = (ccv_cnnp_model_dense_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dense_t));
1519 model_dense->super.isa = &ccv_cnnp_dense_isa;
1520 model_dense->super.input_size = 1;
1521 model_dense->super.outputs = &model_dense->output;
1522 model_dense->super.output_size = 1;
1523 model_dense->super.is_trainable = is_trainable;
1524 ccv_cnnp_model_copy_name(&model_dense->super, name);
1525 model_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
1526 model_dense->weights.graph = 0;
1527 model_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
1528 model_dense->bias.graph = 0;
1529 model_dense->count = count;
1530 model_dense->no_bias = no_bias;
1531 model_dense->flags = flags;
1532 return (ccv_cnnp_model_t*)model_dense;
1533}
1534
1535static ccv_cnnp_model_t* _ccv_cnnp_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
1536{
1537 const ccv_cnnp_model_dense_t* const self = (const ccv_cnnp_model_dense_t*)super;
1538 return ccv_cnnp_dense(self->count, self->no_bias, self->flags, self->super.is_trainable, self->super.name);
1539}
1540
1541// MARK - Pool Layers
1542
1543typedef struct {
1544 ccv_cnnp_model_t super;
1545 ccv_nnc_tensor_symbol_t output;
1546 int kdim[CCV_NNC_MAX_DIM_ALLOC(12)];
1547 ccv_nnc_hint_t hint;
1548} ccv_cnnp_model_pool_t;
1549
1550static 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)
1551{
1552 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1553 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);
1554 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"
, 1554, __extension__ __PRETTY_FUNCTION__); }));
1555 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", 1555, __extension__ __PRETTY_FUNCTION__
); }));
1556 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1557 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1558 ccv_nnc_cmd_t cmd;
1559 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1560 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);
1561 else
1562 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);
1563 ccv_nnc_tensor_param_t output_params;
1564 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1565 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1566 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");
1567 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1568 outputs[0] = pool_output;
1569}
1570
1571static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1572
1573static const ccv_cnnp_model_vtab_t ccv_cnnp_max_pool_isa = {
1574 .build = _ccv_cnnp_max_pool_build,
1575 .copy = _ccv_cnnp_max_pool_copy,
1576};
1577
1578ccv_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)
1579{
1580 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1581 model_pool->super.isa = &ccv_cnnp_max_pool_isa;
1582 model_pool->super.input_size = 1;
1583 model_pool->super.outputs = &model_pool->output;
1584 model_pool->super.output_size = 1;
1585 ccv_cnnp_model_copy_name(&model_pool->super, name);
1586 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1587 model_pool->hint = hint;
1588 return (ccv_cnnp_model_t*)model_pool;
1589}
1590
1591static ccv_cnnp_model_t* _ccv_cnnp_max_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1592{
1593 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1594 return ccv_cnnp_max_pool(self->kdim, self->hint, self->super.name);
1595}
1596
1597static 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)
1598{
1599 ccv_cnnp_model_pool_t* const self = (ccv_cnnp_model_pool_t*)super;
1600 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);
1601 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"
, 1601, __extension__ __PRETTY_FUNCTION__); }));
1602 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", 1602, __extension__ __PRETTY_FUNCTION__
); }));
1603 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1604 const int hw = ccv_nnc_tensor_hw(params, ccv_nnc_tensor_nd(params.dim), CCV_NNC_MAX_DIM(2));
1605 ccv_nnc_cmd_t cmd;
1606 if (hw >= 0 && self->kdim[0] == 0 && self->kdim[1] == 0)
1607 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);
1608 else
1609 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);
1610 ccv_nnc_tensor_param_t output_params;
1611 ccv_nnc_hint_tensor_auto(cmd, &params, 1, self->hint, &output_params, 1);
1612 const ccv_nnc_tensor_symbol_t pool_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1613 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");
1614 ccv_nnc_graph_exec_symbol_set_hint(graph, exec, self->hint);
1615 outputs[0] = pool_output;
1616}
1617
1618static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context);
1619
1620static const ccv_cnnp_model_vtab_t ccv_cnnp_average_pool_isa = {
1621 .build = _ccv_cnnp_average_pool_build,
1622 .copy = _ccv_cnnp_average_pool_copy,
1623};
1624
1625ccv_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)
1626{
1627 ccv_cnnp_model_pool_t* const model_pool = (ccv_cnnp_model_pool_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pool_t));
1628 model_pool->super.isa = &ccv_cnnp_average_pool_isa;
1629 model_pool->super.input_size = 1;
1630 model_pool->super.outputs = &model_pool->output;
1631 model_pool->super.output_size = 1;
1632 ccv_cnnp_model_copy_name(&model_pool->super, name);
1633 memcpy(model_pool->kdim, kdim, sizeof(model_pool->kdim));
1634 model_pool->hint = hint;
1635 return (ccv_cnnp_model_t*)model_pool;
1636}
1637
1638static ccv_cnnp_model_t* _ccv_cnnp_average_pool_copy(const ccv_cnnp_model_t* const super, void* const context)
1639{
1640 const ccv_cnnp_model_pool_t* const self = (const ccv_cnnp_model_pool_t*)super;
1641 return ccv_cnnp_average_pool(self->kdim, self->hint, self->super.name);
1642}
1643
1644// MARK - RELU Layer
1645
1646typedef struct {
1647 ccv_cnnp_model_t super;
1648 ccv_nnc_tensor_symbol_t output;
1649} ccv_cnnp_model_relu_t;
1650
1651static 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)
1652{
1653 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);
1654 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"
, 1654, __extension__ __PRETTY_FUNCTION__); }));
1655 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", 1655, __extension__ __PRETTY_FUNCTION__
); }));
1656 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1657 ccv_nnc_tensor_param_t output_params;
1658 const ccv_nnc_cmd_t relu = CMD_RELU_FORWARD()ccv_nnc_cmd(CCV_NNC_RELU_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1659 ccv_nnc_hint_tensor_auto(relu, (ccv_nnc_tensor_param_t []){
1660 params,
1661 }, 1, ccv_nnc_no_hint, &output_params, 1);
1662 const ccv_nnc_tensor_symbol_t relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1663 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");
1664 outputs[0] = relu_output;
1665}
1666
1667static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
1668
1669static const ccv_cnnp_model_vtab_t ccv_cnnp_relu_isa = {
1670 .build = _ccv_cnnp_relu_build,
1671 .copy = _ccv_cnnp_relu_copy,
1672};
1673
1674ccv_cnnp_model_t* ccv_cnnp_relu(const char* const name)
1675{
1676 ccv_cnnp_model_relu_t* const model_relu = (ccv_cnnp_model_relu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_relu_t));
1677 model_relu->super.isa = &ccv_cnnp_relu_isa;
1678 model_relu->super.input_size = 1;
1679 model_relu->super.outputs = &model_relu->output;
1680 model_relu->super.output_size = 1;
1681 ccv_cnnp_model_copy_name(&model_relu->super, name);
1682 return (ccv_cnnp_model_t*)model_relu;
1683}
1684
1685static ccv_cnnp_model_t* _ccv_cnnp_relu_copy(const ccv_cnnp_model_t* const self, void* const context)
1686{
1687 return ccv_cnnp_relu(self->name);
1688}
1689
1690// MARK - Sigmoid Layer
1691
1692typedef struct {
1693 ccv_cnnp_model_t super;
1694 ccv_nnc_tensor_symbol_t output;
1695} ccv_cnnp_model_sigmoid_t;
1696
1697static 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)
1698{
1699 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);
1700 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"
, 1700, __extension__ __PRETTY_FUNCTION__); }));
1701 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", 1701, __extension__ __PRETTY_FUNCTION__
); }));
1702 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1703 ccv_nnc_tensor_param_t output_params;
1704 const ccv_nnc_cmd_t sigmoid = CMD_SIGMOID_FORWARD()ccv_nnc_cmd(CCV_NNC_SIGMOID_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1705 ccv_nnc_hint_tensor_auto(sigmoid, (ccv_nnc_tensor_param_t []){
1706 params,
1707 }, 1, ccv_nnc_no_hint, &output_params, 1);
1708 const ccv_nnc_tensor_symbol_t sigmoid_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1709 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");
1710 outputs[0] = sigmoid_output;
1711}
1712
1713static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context);
1714
1715static const ccv_cnnp_model_vtab_t ccv_cnnp_sigmoid_isa = {
1716 .build = _ccv_cnnp_sigmoid_build,
1717 .copy = _ccv_cnnp_sigmoid_copy,
1718};
1719
1720ccv_cnnp_model_t* ccv_cnnp_sigmoid(const char* const name)
1721{
1722 ccv_cnnp_model_sigmoid_t* const model_sigmoid = (ccv_cnnp_model_sigmoid_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sigmoid_t));
1723 model_sigmoid->super.isa = &ccv_cnnp_sigmoid_isa;
1724 model_sigmoid->super.input_size = 1;
1725 model_sigmoid->super.outputs = &model_sigmoid->output;
1726 model_sigmoid->super.output_size = 1;
1727 ccv_cnnp_model_copy_name(&model_sigmoid->super, name);
1728 return (ccv_cnnp_model_t*)model_sigmoid;
1729}
1730
1731static ccv_cnnp_model_t* _ccv_cnnp_sigmoid_copy(const ccv_cnnp_model_t* const self, void* const context)
1732{
1733 return ccv_cnnp_sigmoid(self->name);
1734}
1735
1736// MARK - Tanh Layer
1737
1738typedef struct {
1739 ccv_cnnp_model_t super;
1740 ccv_nnc_tensor_symbol_t output;
1741 float soft_cap;
1742} ccv_cnnp_model_tanh_t;
1743
1744static 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)
1745{
1746 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);
1747 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"
, 1747, __extension__ __PRETTY_FUNCTION__); }));
1748 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", 1748, __extension__ __PRETTY_FUNCTION__
); }));
1749 ccv_cnnp_model_tanh_t* const self = (ccv_cnnp_model_tanh_t*)super;
1750 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1751 ccv_nnc_tensor_param_t output_params;
1752 const ccv_nnc_cmd_t tanh = CMD_TANH_FORWARD(self->soft_cap)ccv_nnc_cmd(CCV_NNC_TANH_FORWARD, 0, ((ccv_nnc_cmd_param_t){.
size={.dim={1,1,1}},.tanh={.soft_cap=self->soft_cap}}), 0);
1753 ccv_nnc_hint_tensor_auto(tanh, (ccv_nnc_tensor_param_t []){
1754 params,
1755 }, 1, ccv_nnc_no_hint, &output_params, 1);
1756 const ccv_nnc_tensor_symbol_t tanh_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1757 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");
1758 outputs[0] = tanh_output;
1759}
1760
1761static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const self, void* const context);
1762
1763static const ccv_cnnp_model_vtab_t ccv_cnnp_tanh_isa = {
1764 .build = _ccv_cnnp_tanh_build,
1765 .copy = _ccv_cnnp_tanh_copy,
1766};
1767
1768ccv_cnnp_model_t* ccv_cnnp_tanh(const float soft_cap, const char* const name)
1769{
1770 ccv_cnnp_model_tanh_t* const model_tanh = (ccv_cnnp_model_tanh_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_tanh_t));
1771 model_tanh->super.isa = &ccv_cnnp_tanh_isa;
1772 model_tanh->super.input_size = 1;
1773 model_tanh->super.outputs = &model_tanh->output;
1774 model_tanh->super.output_size = 1;
1775 model_tanh->soft_cap = soft_cap;
1776 ccv_cnnp_model_copy_name(&model_tanh->super, name);
1777 return (ccv_cnnp_model_t*)model_tanh;
1778}
1779
1780static ccv_cnnp_model_t* _ccv_cnnp_tanh_copy(const ccv_cnnp_model_t* const super, void* const context)
1781{
1782 const ccv_cnnp_model_tanh_t* const self = (const ccv_cnnp_model_tanh_t*)super;
1783 return ccv_cnnp_tanh(self->soft_cap, self->super.name);
1784}
1785
1786// MARK - Exp Layer
1787
1788typedef struct {
1789 ccv_cnnp_model_t super;
1790 ccv_nnc_tensor_symbol_t output;
1791} ccv_cnnp_model_exp_t;
1792
1793static 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)
1794{
1795 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);
1796 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"
, 1796, __extension__ __PRETTY_FUNCTION__); }));
1797 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", 1797, __extension__ __PRETTY_FUNCTION__
); }));
1798 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1799 ccv_nnc_tensor_param_t output_params;
1800 const ccv_nnc_cmd_t exp = CMD_EWEXP_FORWARD()ccv_nnc_cmd(CCV_NNC_EWEXP_FORWARD, 0, ccv_nnc_cmd_auto, 0);
1801 ccv_nnc_hint_tensor_auto(exp, (ccv_nnc_tensor_param_t []){
1802 params,
1803 }, 1, ccv_nnc_no_hint, &output_params, 1);
1804 const ccv_nnc_tensor_symbol_t exp_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1805 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");
1806 outputs[0] = exp_output;
1807}
1808
1809static ccv_cnnp_model_t* _ccv_cnnp_exp_copy(const ccv_cnnp_model_t* const self, void* const context);
1810
1811static const ccv_cnnp_model_vtab_t ccv_cnnp_exp_isa = {
1812 .build = _ccv_cnnp_exp_build,
1813 .copy = _ccv_cnnp_exp_copy,
1814};
1815
1816ccv_cnnp_model_t* ccv_cnnp_exp(const char* const name)
1817{
1818 ccv_cnnp_model_exp_t* const model_exp = (ccv_cnnp_model_exp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_exp_t));
1819 model_exp->super.isa = &ccv_cnnp_exp_isa;
1820 model_exp->super.input_size = 1;
1821 model_exp->super.outputs = &model_exp->output;
1822 model_exp->super.output_size = 1;
1823 ccv_cnnp_model_copy_name(&model_exp->super, name);
1824 return (ccv_cnnp_model_t*)model_exp;
1825}
1826
1827static ccv_cnnp_model_t* _ccv_cnnp_exp_copy(const ccv_cnnp_model_t* const self, void* const context)
1828{
1829 return ccv_cnnp_exp(self->name);
1830}
1831
1832// MARK - Softplus Layer
1833
1834typedef struct {
1835 ccv_cnnp_model_t super;
1836 ccv_nnc_tensor_symbol_t output;
1837} ccv_cnnp_model_softplus_t;
1838
1839static 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)
1840{
1841 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);
1842 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"
, 1842, __extension__ __PRETTY_FUNCTION__); }));
1843 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", 1843, __extension__ __PRETTY_FUNCTION__
); }));
1844 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1845 ccv_nnc_tensor_param_t output_params;
1846 const ccv_nnc_cmd_t softplus = CMD_EWSOFTPLUS_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSOFTPLUS_FORWARD, 0, ccv_nnc_cmd_auto, 0
);
1847 ccv_nnc_hint_tensor_auto(softplus, (ccv_nnc_tensor_param_t []){
1848 params,
1849 }, 1, ccv_nnc_no_hint, &output_params, 1);
1850 const ccv_nnc_tensor_symbol_t softplus_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1851 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");
1852 outputs[0] = softplus_output;
1853}
1854
1855static ccv_cnnp_model_t* _ccv_cnnp_softplus_copy(const ccv_cnnp_model_t* const self, void* const context);
1856
1857static const ccv_cnnp_model_vtab_t ccv_cnnp_softplus_isa = {
1858 .build = _ccv_cnnp_softplus_build,
1859 .copy = _ccv_cnnp_softplus_copy,
1860};
1861
1862ccv_cnnp_model_t* ccv_cnnp_softplus(const char* const name)
1863{
1864 ccv_cnnp_model_softplus_t* const model_softplus = (ccv_cnnp_model_softplus_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softplus_t));
1865 model_softplus->super.isa = &ccv_cnnp_softplus_isa;
1866 model_softplus->super.input_size = 1;
1867 model_softplus->super.outputs = &model_softplus->output;
1868 model_softplus->super.output_size = 1;
1869 ccv_cnnp_model_copy_name(&model_softplus->super, name);
1870 return (ccv_cnnp_model_t*)model_softplus;
1871}
1872
1873static ccv_cnnp_model_t* _ccv_cnnp_softplus_copy(const ccv_cnnp_model_t* const self, void* const context)
1874{
1875 return ccv_cnnp_softplus(self->name);
1876}
1877
1878// MARK - Swish Layer
1879
1880typedef struct {
1881 ccv_cnnp_model_t super;
1882 ccv_nnc_tensor_symbol_t output;
1883 float beta;
1884} ccv_cnnp_model_swish_t;
1885
1886static 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)
1887{
1888 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);
1889 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"
, 1889, __extension__ __PRETTY_FUNCTION__); }));
1890 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", 1890, __extension__ __PRETTY_FUNCTION__
); }));
1891 ccv_cnnp_model_swish_t* const self = (ccv_cnnp_model_swish_t*)super;
1892 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1893 ccv_nnc_tensor_param_t output_params;
1894 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);
1895 ccv_nnc_hint_tensor_auto(swish, (ccv_nnc_tensor_param_t []){
1896 params,
1897 }, 1, ccv_nnc_no_hint, &output_params, 1);
1898 const ccv_nnc_tensor_symbol_t swish_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1899 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");
1900 outputs[0] = swish_output;
1901}
1902
1903static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context);
1904
1905static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_isa = {
1906 .build = _ccv_cnnp_swish_build,
1907 .copy = _ccv_cnnp_swish_copy,
1908};
1909
1910ccv_cnnp_model_t* ccv_cnnp_swish(const float beta, const char* const name)
1911{
1912 ccv_cnnp_model_swish_t* const model_swish = (ccv_cnnp_model_swish_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swish_t));
1913 model_swish->super.isa = &ccv_cnnp_swish_isa;
1914 model_swish->super.input_size = 1;
1915 model_swish->super.outputs = &model_swish->output;
1916 model_swish->super.output_size = 1;
1917 model_swish->beta = beta;
1918 ccv_cnnp_model_copy_name(&model_swish->super, name);
1919 return (ccv_cnnp_model_t*)model_swish;
1920}
1921
1922static ccv_cnnp_model_t* _ccv_cnnp_swish_copy(const ccv_cnnp_model_t* const self, void* const context)
1923{
1924 const ccv_cnnp_model_swish_t* const swish = (const ccv_cnnp_model_swish_t*)self;
1925 return ccv_cnnp_swish(swish->beta, self->name);
1926}
1927
1928// MARK - Swish Mul Layer
1929
1930typedef struct {
1931 ccv_cnnp_model_t super;
1932 ccv_nnc_tensor_symbol_t output;
1933 float beta;
1934 float scale;
1935} ccv_cnnp_model_swish_mul_t;
1936
1937static 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)
1938{
1939 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);
1940 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"
, 1940, __extension__ __PRETTY_FUNCTION__); }));
1941 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", 1941, __extension__ __PRETTY_FUNCTION__
); }));
1942 const ccv_cnnp_model_swish_mul_t* const self = (const ccv_cnnp_model_swish_mul_t*)super;
1943 ccv_nnc_tensor_param_t input_params[2];
1944 int i;
1945 for (i = 0; i < 2; i++)
1946 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
1947 ccv_nnc_tensor_param_t output_params;
1948 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);
1949 ccv_nnc_hint_tensor_auto(swish_mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
1950 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
1951 ccv_nnc_graph_exec_symbol_new(graph, swish_mul, inputs, input_size, outputs, output_size, "swish_mul");
1952}
1953
1954static ccv_cnnp_model_t* _ccv_cnnp_swish_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
1955
1956static const ccv_cnnp_model_vtab_t ccv_cnnp_swish_mul_isa = {
1957 .build = _ccv_cnnp_swish_mul_build,
1958 .copy = _ccv_cnnp_swish_mul_copy,
1959};
1960
1961ccv_cnnp_model_t* ccv_cnnp_swish_mul(const float beta, const float scale, const char* const name)
1962{
1963 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));
1964 model_swish_mul->super.isa = &ccv_cnnp_swish_mul_isa;
1965 model_swish_mul->super.input_size = 2;
1966 model_swish_mul->super.outputs = &model_swish_mul->output;
1967 model_swish_mul->super.output_size = 1;
1968 model_swish_mul->beta = beta;
1969 model_swish_mul->scale = scale;
1970 ccv_cnnp_model_copy_name(&model_swish_mul->super, name);
1971 return (ccv_cnnp_model_t*)model_swish_mul;
1972}
1973
1974static ccv_cnnp_model_t* _ccv_cnnp_swish_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
1975{
1976 const ccv_cnnp_model_swish_mul_t* const self = (const ccv_cnnp_model_swish_mul_t*)super;
1977 return ccv_cnnp_swish_mul(self->beta, self->scale, self->super.name);
1978}
1979
1980// MARK - GELU Layer
1981
1982typedef struct {
1983 ccv_cnnp_model_t super;
1984 ccv_nnc_tensor_symbol_t output;
1985 int tanh;
1986} ccv_cnnp_model_gelu_t;
1987
1988static 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)
1989{
1990 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);
1991 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"
, 1991, __extension__ __PRETTY_FUNCTION__); }));
1992 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", 1992, __extension__ __PRETTY_FUNCTION__
); }));
1993 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
1994 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
1995 ccv_nnc_tensor_param_t output_params;
1996 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);
1997 ccv_nnc_hint_tensor_auto(gelu, (ccv_nnc_tensor_param_t []){
1998 params,
1999 }, 1, ccv_nnc_no_hint, &output_params, 1);
2000 const ccv_nnc_tensor_symbol_t gelu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2001 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");
2002 outputs[0] = gelu_output;
2003}
2004
2005static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const self, void* const context);
2006
2007static const ccv_cnnp_model_vtab_t ccv_cnnp_gelu_isa = {
2008 .build = _ccv_cnnp_gelu_build,
2009 .copy = _ccv_cnnp_gelu_copy,
2010};
2011
2012ccv_cnnp_model_t* ccv_cnnp_gelu(const int tanh, const char* const name)
2013{
2014 ccv_cnnp_model_gelu_t* const model_gelu = (ccv_cnnp_model_gelu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gelu_t));
2015 model_gelu->super.isa = &ccv_cnnp_gelu_isa;
2016 model_gelu->super.input_size = 1;
2017 model_gelu->super.outputs = &model_gelu->output;
2018 model_gelu->super.output_size = 1;
2019 model_gelu->tanh = tanh;
2020 ccv_cnnp_model_copy_name(&model_gelu->super, name);
2021 return (ccv_cnnp_model_t*)model_gelu;
2022}
2023
2024static ccv_cnnp_model_t* _ccv_cnnp_gelu_copy(const ccv_cnnp_model_t* const super, void* const context)
2025{
2026 ccv_cnnp_model_gelu_t* const self = (ccv_cnnp_model_gelu_t*)super;
2027 return ccv_cnnp_gelu(self->tanh, self->super.name);
2028}
2029
2030// MARK - Leaky ReLU Layer
2031
2032typedef struct {
2033 ccv_cnnp_model_t super;
2034 ccv_nnc_tensor_symbol_t output;
2035 float negative_slope;
2036} ccv_cnnp_model_leaky_relu_t;
2037
2038static 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)
2039{
2040 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);
2041 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"
, 2041, __extension__ __PRETTY_FUNCTION__); }));
2042 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", 2042, __extension__ __PRETTY_FUNCTION__
); }));
2043 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
2044 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2045 ccv_nnc_tensor_param_t output_params;
2046 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);
2047 ccv_nnc_hint_tensor_auto(leaky_relu, (ccv_nnc_tensor_param_t []){
2048 params,
2049 }, 1, ccv_nnc_no_hint, &output_params, 1);
2050 const ccv_nnc_tensor_symbol_t leaky_relu_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2051 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");
2052 outputs[0] = leaky_relu_output;
2053}
2054
2055static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const self, void* const context);
2056
2057static const ccv_cnnp_model_vtab_t ccv_cnnp_leaky_relu_isa = {
2058 .build = _ccv_cnnp_leaky_relu_build,
2059 .copy = _ccv_cnnp_leaky_relu_copy,
2060};
2061
2062ccv_cnnp_model_t* ccv_cnnp_leaky_relu(const float negative_slope, const char* const name)
2063{
2064 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));
2065 model_leaky_relu->super.isa = &ccv_cnnp_leaky_relu_isa;
2066 model_leaky_relu->super.input_size = 1;
2067 model_leaky_relu->super.outputs = &model_leaky_relu->output;
2068 model_leaky_relu->super.output_size = 1;
2069 model_leaky_relu->negative_slope = negative_slope;
2070 ccv_cnnp_model_copy_name(&model_leaky_relu->super, name);
2071 return (ccv_cnnp_model_t*)model_leaky_relu;
2072}
2073
2074static ccv_cnnp_model_t* _ccv_cnnp_leaky_relu_copy(const ccv_cnnp_model_t* const super, void* const context)
2075{
2076 ccv_cnnp_model_leaky_relu_t* const self = (ccv_cnnp_model_leaky_relu_t*)super;
2077 return ccv_cnnp_leaky_relu(self->negative_slope, self->super.name);
2078}
2079
2080// MARK - Softmax Layer
2081
2082typedef struct {
2083 ccv_cnnp_model_t super;
2084 ccv_nnc_tensor_symbol_t output;
2085} ccv_cnnp_model_softmax_t;
2086
2087static 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)
2088{
2089 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);
2090 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"
, 2090, __extension__ __PRETTY_FUNCTION__); }));
2091 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", 2091, __extension__ __PRETTY_FUNCTION__
); }));
2092 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2093 ccv_nnc_tensor_param_t output_params;
2094 const ccv_nnc_cmd_t softmax = CMD_SOFTMAX_FORWARD()ccv_nnc_cmd(CCV_NNC_SOFTMAX_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2095 ccv_nnc_hint_tensor_auto(softmax, (ccv_nnc_tensor_param_t []){
2096 params,
2097 }, 1, ccv_nnc_no_hint, &output_params, 1);
2098 const ccv_nnc_tensor_symbol_t softmax_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2099 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");
2100 outputs[0] = softmax_output;
2101}
2102
2103static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context);
2104
2105static const ccv_cnnp_model_vtab_t ccv_cnnp_softmax_isa = {
2106 .build = _ccv_cnnp_softmax_build,
2107 .copy = _ccv_cnnp_softmax_copy,
2108};
2109
2110ccv_cnnp_model_t* ccv_cnnp_softmax(const char* const name)
2111{
2112 ccv_cnnp_model_softmax_t* const model_softmax = (ccv_cnnp_model_softmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_softmax_t));
2113 model_softmax->super.isa = &ccv_cnnp_softmax_isa;
2114 model_softmax->super.input_size = 1;
2115 model_softmax->super.outputs = &model_softmax->output;
2116 model_softmax->super.output_size = 1;
2117 ccv_cnnp_model_copy_name(&model_softmax->super, name);
2118 return (ccv_cnnp_model_t*)model_softmax;
2119}
2120
2121static ccv_cnnp_model_t* _ccv_cnnp_softmax_copy(const ccv_cnnp_model_t* const self, void* const context)
2122{
2123 return ccv_cnnp_softmax(self->name);
2124}
2125
2126// MARK - Add Layer
2127
2128typedef struct {
2129 ccv_cnnp_model_t super;
2130 float p;
2131 float q;
2132 ccv_nnc_tensor_symbol_t output;
2133} ccv_cnnp_model_add_t;
2134
2135static 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)
2136{
2137 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);
2138 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
2139 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"
, 2139, __extension__ __PRETTY_FUNCTION__); }));
2140 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", 2140, __extension__ __PRETTY_FUNCTION__
); }));
2141 ccv_nnc_tensor_param_t input_params[2];
2142 int i;
2143 for (i = 0; i < 2; i++)
2144 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2145 ccv_nnc_tensor_param_t output_params;
2146 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);
2147 ccv_nnc_hint_tensor_auto(add, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2148 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2149 ccv_nnc_graph_exec_symbol_new(graph, add, inputs, input_size, outputs, output_size, "add");
2150}
2151
2152static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const self, void* const context);
2153
2154static const ccv_cnnp_model_vtab_t ccv_cnnp_add_isa = {
2155 .build = _ccv_cnnp_add_build,
2156 .copy = _ccv_cnnp_add_copy,
2157};
2158
2159ccv_cnnp_model_t* ccv_cnnp_add(const float p, const float q, const char* const name)
2160{
2161 ccv_cnnp_model_add_t* const model_add = (ccv_cnnp_model_add_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_add_t));
2162 model_add->super.isa = &ccv_cnnp_add_isa;
2163 model_add->super.input_size = 2;
2164 model_add->super.outputs = &model_add->output;
2165 model_add->super.output_size = 1;
2166 model_add->p = p;
2167 model_add->q = q;
2168 ccv_cnnp_model_copy_name(&model_add->super, name);
2169 return (ccv_cnnp_model_t*)model_add;
2170}
2171
2172static ccv_cnnp_model_t* _ccv_cnnp_add_copy(const ccv_cnnp_model_t* const super, void* const context)
2173{
2174 const ccv_cnnp_model_add_t* const self = (const ccv_cnnp_model_add_t*)super;
2175 return ccv_cnnp_add(self->p, self->q, self->super.name);
2176}
2177
2178// MARK - Mul Layer
2179
2180typedef struct {
2181 ccv_cnnp_model_t super;
2182 ccv_nnc_tensor_symbol_t output;
2183 float p;
2184} ccv_cnnp_model_mul_t;
2185
2186static 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)
2187{
2188 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);
2189 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2190 assert(input_size == 2)((void) sizeof ((input_size == 2) ? 1 : 0), __extension__ ({ if
(input_size == 2) ; else __assert_fail ("input_size == 2", "ccv_cnnp_model_addons.c"
, 2190, __extension__ __PRETTY_FUNCTION__); }));
2191 assert(output_size == 1)((void) sizeof ((output_size == 1) ? 1 : 0), __extension__ ({
if (output_size == 1) ; else __assert_fail ("output_size == 1"
, "ccv_cnnp_model_addons.c", 2191, __extension__ __PRETTY_FUNCTION__
); }));
2192 ccv_nnc_tensor_param_t input_params[2];
2193 int i;
2194 for (i = 0; i < 2; i++)
2195 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2196 ccv_nnc_tensor_param_t output_params;
2197 const ccv_nnc_cmd_t mul = CMD_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);
2198 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2199 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2200 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "mul");
2201}
2202
2203static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const self, void* const context);
2204
2205static const ccv_cnnp_model_vtab_t ccv_cnnp_mul_isa = {
2206 .build = _ccv_cnnp_mul_build,
2207 .copy = _ccv_cnnp_mul_copy,
2208};
2209
2210ccv_cnnp_model_t* ccv_cnnp_mul(const float p, const char* const name)
2211{
2212 ccv_cnnp_model_mul_t* const model_mul = (ccv_cnnp_model_mul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_mul_t));
2213 model_mul->super.isa = &ccv_cnnp_mul_isa;
2214 model_mul->super.input_size = 2;
2215 model_mul->super.outputs = &model_mul->output;
2216 model_mul->super.output_size = 1;
2217 model_mul->p = p;
2218 ccv_cnnp_model_copy_name(&model_mul->super, name);
2219 return (ccv_cnnp_model_t*)model_mul;
2220}
2221
2222static ccv_cnnp_model_t* _ccv_cnnp_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2223{
2224 const ccv_cnnp_model_mul_t* const self = (const ccv_cnnp_model_mul_t*)super;
2225 return ccv_cnnp_mul(self->p, self->super.name);
2226}
2227
2228// MARK - Scalar Mul Layer
2229
2230typedef struct {
2231 ccv_cnnp_model_t super;
2232 ccv_nnc_tensor_symbol_t output;
2233 float a;
2234} ccv_cnnp_model_scalar_mul_t;
2235
2236static 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)
2237{
2238 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);
2239 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"
, 2239, __extension__ __PRETTY_FUNCTION__); }));
2240 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", 2240, __extension__ __PRETTY_FUNCTION__
); }));
2241 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2242 ccv_nnc_tensor_param_t output_params;
2243 ccv_cnnp_model_scalar_mul_t* const self = (ccv_cnnp_model_scalar_mul_t*)super;
2244 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);
2245 ccv_nnc_hint_tensor_auto(scalar_mul, (ccv_nnc_tensor_param_t []){
2246 params,
2247 }, 1, ccv_nnc_no_hint, &output_params, 1);
2248 const ccv_nnc_tensor_symbol_t scalar_mul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2249 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");
2250 outputs[0] = scalar_mul_output;
2251}
2252
2253static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context);
2254
2255static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_mul_isa = {
2256 .build = _ccv_cnnp_scalar_mul_build,
2257 .copy = _ccv_cnnp_scalar_mul_copy,
2258};
2259
2260ccv_cnnp_model_t* ccv_cnnp_scalar_mul(const float a, const char* const name)
2261{
2262 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));
2263 model_scalar_mul->super.isa = &ccv_cnnp_scalar_mul_isa;
2264 model_scalar_mul->super.input_size = 1;
2265 model_scalar_mul->super.outputs = &model_scalar_mul->output;
2266 model_scalar_mul->super.output_size = 1;
2267 model_scalar_mul->a = a;
2268 ccv_cnnp_model_copy_name(&model_scalar_mul->super, name);
2269 return (ccv_cnnp_model_t*)model_scalar_mul;
2270}
2271
2272static ccv_cnnp_model_t* _ccv_cnnp_scalar_mul_copy(const ccv_cnnp_model_t* const super, void* const context)
2273{
2274 const ccv_cnnp_model_scalar_mul_t* const self = (const ccv_cnnp_model_scalar_mul_t*)super;
2275 return ccv_cnnp_scalar_mul(self->a, self->super.name);
2276}
2277
2278// MARK - Div Layer
2279
2280typedef struct {
2281 ccv_cnnp_model_t super;
2282 ccv_nnc_tensor_symbol_t output;
2283 int reciprocal;
2284} ccv_cnnp_model_div_t;
2285
2286static 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)
2287{
2288 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2289 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);
2290 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", 2290, __extension__ __PRETTY_FUNCTION__
); }));
2291 ccv_nnc_tensor_param_t input_params[2];
2292 int i;
2293 ccv_nnc_tensor_param_t output_params;
2294 const ccv_nnc_cmd_t div = CMD_EWDIV_FORWARD()ccv_nnc_cmd(CCV_NNC_EWDIV_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2295 if (self->reciprocal)
2296 {
2297 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"
, 2297, __extension__ __PRETTY_FUNCTION__); }));
2298 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2299 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2300 ccv_nnc_hint_tensor_auto(div, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2301 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2302 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");
2303 } else {
2304 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"
, 2304, __extension__ __PRETTY_FUNCTION__); }));
2305 for (i = 0; i < 2; i++)
2306 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2307 ccv_nnc_hint_tensor_auto(div, input_params, input_size, ccv_nnc_no_hint, &output_params, 1);
2308 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2309 ccv_nnc_graph_exec_symbol_new(graph, div, inputs, input_size, outputs, output_size, "div");
2310 }
2311}
2312
2313static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const self, void* const context);
2314
2315static const ccv_cnnp_model_vtab_t ccv_cnnp_div_isa = {
2316 .build = _ccv_cnnp_div_build,
2317 .copy = _ccv_cnnp_div_copy,
2318};
2319
2320ccv_cnnp_model_t* ccv_cnnp_div(const int reciprocal, const char* const name)
2321{
2322 ccv_cnnp_model_div_t* const model_div = (ccv_cnnp_model_div_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_div_t));
2323 model_div->super.isa = &ccv_cnnp_div_isa;
2324 model_div->super.input_size = reciprocal ? 1 : 2;
2325 model_div->super.outputs = &model_div->output;
2326 model_div->super.output_size = 1;
2327 model_div->reciprocal = reciprocal;
2328 ccv_cnnp_model_copy_name(&model_div->super, name);
2329 return (ccv_cnnp_model_t*)model_div;
2330}
2331
2332static ccv_cnnp_model_t* _ccv_cnnp_div_copy(const ccv_cnnp_model_t* const super, void* const context)
2333{
2334 const ccv_cnnp_model_div_t* const self = (const ccv_cnnp_model_div_t*)super;
2335 return ccv_cnnp_div(self->reciprocal, self->super.name);
2336}
2337
2338// MARK - Sqrt Layer
2339
2340typedef struct {
2341 ccv_cnnp_model_t super;
2342 ccv_nnc_tensor_symbol_t output;
2343} ccv_cnnp_model_sqrt_t;
2344
2345static 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)
2346{
2347 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);
2348 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", 2348, __extension__ __PRETTY_FUNCTION__
); }));
2349 ccv_nnc_tensor_param_t input_params[1];
2350 ccv_nnc_tensor_param_t output_params;
2351 const ccv_nnc_cmd_t sqrt = CMD_EWSQRT_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSQRT_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2352 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"
, 2352, __extension__ __PRETTY_FUNCTION__); }));
2353 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2354 ccv_nnc_hint_tensor_auto(sqrt, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2355 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2356 ccv_nnc_graph_exec_symbol_new(graph, sqrt, inputs, 1, outputs, output_size, "sqrt");
2357}
2358
2359static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const self, void* const context);
2360
2361static const ccv_cnnp_model_vtab_t ccv_cnnp_sqrt_isa = {
2362 .build = _ccv_cnnp_sqrt_build,
2363 .copy = _ccv_cnnp_sqrt_copy,
2364};
2365
2366ccv_cnnp_model_t* ccv_cnnp_sqrt(const char* const name)
2367{
2368 ccv_cnnp_model_sqrt_t* const model_sqrt = (ccv_cnnp_model_sqrt_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sqrt_t));
2369 model_sqrt->super.isa = &ccv_cnnp_sqrt_isa;
2370 model_sqrt->super.input_size = 1;
2371 model_sqrt->super.outputs = &model_sqrt->output;
2372 model_sqrt->super.output_size = 1;
2373 ccv_cnnp_model_copy_name(&model_sqrt->super, name);
2374 return (ccv_cnnp_model_t*)model_sqrt;
2375}
2376
2377static ccv_cnnp_model_t* _ccv_cnnp_sqrt_copy(const ccv_cnnp_model_t* const super, void* const context)
2378{
2379 const ccv_cnnp_model_sqrt_t* const self = (const ccv_cnnp_model_sqrt_t*)super;
2380 return ccv_cnnp_sqrt(self->super.name);
2381}
2382
2383// MARK - Signed Sqrt Layer
2384
2385typedef struct {
2386 ccv_cnnp_model_t super;
2387 ccv_nnc_tensor_symbol_t output;
2388 float minimum_magnitude;
2389} ccv_cnnp_model_signed_sqrt_t;
2390
2391static void _ccv_cnnp_signed_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)
2392{
2393 PRINT(CCV_CLI_VERBOSE, "[cnnp_signed_sqrt_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_signed_sqrt_build] -\n"); fflush(stdout); } }
while (0);
2394 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"
, 2394, __extension__ __PRETTY_FUNCTION__); }));
2395 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", 2395, __extension__ __PRETTY_FUNCTION__
); }));
2396 const ccv_cnnp_model_signed_sqrt_t* const self = (const ccv_cnnp_model_signed_sqrt_t*)super;
2397 const ccv_nnc_cmd_t cmd = CMD_SIGNED_SQRT_FORWARD(self->minimum_magnitude)ccv_nnc_cmd(CCV_NNC_SIGNED_SQRT_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.signed_sqrt={.minimum_magnitude=(self
->minimum_magnitude)}}), 0);
2398 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2399 ccv_nnc_tensor_param_t output_params;
2400 ccv_nnc_hint_tensor_auto(cmd, &params, 1, ccv_nnc_no_hint, &output_params, 1);
2401 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2402 ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, input_size, outputs, output_size, "signed_sqrt");
2403}
2404
2405static ccv_cnnp_model_t* _ccv_cnnp_signed_sqrt_copy(const ccv_cnnp_model_t* const self, void* const context);
2406
2407static const ccv_cnnp_model_vtab_t ccv_cnnp_signed_sqrt_isa = {
2408 .build = _ccv_cnnp_signed_sqrt_build,
2409 .copy = _ccv_cnnp_signed_sqrt_copy,
2410};
2411
2412ccv_cnnp_model_t* ccv_cnnp_signed_sqrt(const float minimum_magnitude, const char* const name)
2413{
2414 assert(minimum_magnitude > 0 && isfinite(minimum_magnitude))((void) sizeof ((minimum_magnitude > 0 && __builtin_isfinite
(minimum_magnitude)) ? 1 : 0), __extension__ ({ if (minimum_magnitude
> 0 && __builtin_isfinite (minimum_magnitude)) ; else
__assert_fail ("minimum_magnitude > 0 && isfinite(minimum_magnitude)"
, "ccv_cnnp_model_addons.c", 2414, __extension__ __PRETTY_FUNCTION__
); }));
2415 ccv_cnnp_model_signed_sqrt_t* const model = (ccv_cnnp_model_signed_sqrt_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_signed_sqrt_t));
2416 model->super.isa = &ccv_cnnp_signed_sqrt_isa;
2417 model->super.input_size = 1;
2418 model->super.outputs = &model->output;
2419 model->super.output_size = 1;
2420 model->minimum_magnitude = minimum_magnitude;
2421 ccv_cnnp_model_copy_name(&model->super, name);
2422 return (ccv_cnnp_model_t*)model;
2423}
2424
2425static ccv_cnnp_model_t* _ccv_cnnp_signed_sqrt_copy(const ccv_cnnp_model_t* const super, void* const context)
2426{
2427 const ccv_cnnp_model_signed_sqrt_t* const self = (const ccv_cnnp_model_signed_sqrt_t*)super;
2428 return ccv_cnnp_signed_sqrt(self->minimum_magnitude, self->super.name);
2429}
2430
2431// MARK - Log Layer
2432
2433typedef struct {
2434 ccv_cnnp_model_t super;
2435 ccv_nnc_tensor_symbol_t output;
2436} ccv_cnnp_model_log_t;
2437
2438static 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)
2439{
2440 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);
2441 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", 2441, __extension__ __PRETTY_FUNCTION__
); }));
2442 ccv_nnc_tensor_param_t input_params[1];
2443 ccv_nnc_tensor_param_t output_params;
2444 const ccv_nnc_cmd_t log = CMD_EWLOG_FORWARD()ccv_nnc_cmd(CCV_NNC_EWLOG_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2445 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"
, 2445, __extension__ __PRETTY_FUNCTION__); }));
2446 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2447 ccv_nnc_hint_tensor_auto(log, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2448 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2449 ccv_nnc_graph_exec_symbol_new(graph, log, inputs, 1, outputs, output_size, "log");
2450}
2451
2452static ccv_cnnp_model_t* _ccv_cnnp_log_copy(const ccv_cnnp_model_t* const self, void* const context);
2453
2454static const ccv_cnnp_model_vtab_t ccv_cnnp_log_isa = {
2455 .build = _ccv_cnnp_log_build,
2456 .copy = _ccv_cnnp_log_copy,
2457};
2458
2459ccv_cnnp_model_t* ccv_cnnp_log(const char* const name)
2460{
2461 ccv_cnnp_model_log_t* const model_log = (ccv_cnnp_model_log_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_log_t));
2462 model_log->super.isa = &ccv_cnnp_log_isa;
2463 model_log->super.input_size = 1;
2464 model_log->super.outputs = &model_log->output;
2465 model_log->super.output_size = 1;
2466 ccv_cnnp_model_copy_name(&model_log->super, name);
2467 return (ccv_cnnp_model_t*)model_log;
2468}
2469
2470static ccv_cnnp_model_t* _ccv_cnnp_log_copy(const ccv_cnnp_model_t* const super, void* const context)
2471{
2472 return ccv_cnnp_log(super->name);
2473}
2474
2475// MARK - Pow Layer
2476
2477typedef struct {
2478 ccv_cnnp_model_t super;
2479 ccv_nnc_tensor_symbol_t output;
2480 ccv_nnc_cmd_param_t params;
2481} ccv_cnnp_model_pow_t;
2482
2483static 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)
2484{
2485 ccv_cnnp_model_pow_t* const self = (ccv_cnnp_model_pow_t*)super;
2486 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);
2487 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"
, 2487, __extension__ __PRETTY_FUNCTION__); }));
2488 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", 2488, __extension__ __PRETTY_FUNCTION__
); }));
2489 ccv_nnc_tensor_param_t input_params[1];
2490 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2491 ccv_nnc_tensor_param_t output_params;
2492 const ccv_nnc_cmd_t pow = ccv_nnc_cmd(CCV_NNC_EWPOW_FORWARD, 0, self->params, 0);
2493 ccv_nnc_hint_tensor_auto(pow, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2494 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2495 ccv_nnc_graph_exec_symbol_new(graph, pow, inputs, input_size, outputs, output_size, "pow");
2496}
2497
2498static ccv_cnnp_model_t* _ccv_cnnp_pow_copy(const ccv_cnnp_model_t* const self, void* const context);
2499
2500static const ccv_cnnp_model_vtab_t ccv_cnnp_pow_isa = {
2501 .build = _ccv_cnnp_pow_build,
2502 .copy = _ccv_cnnp_pow_copy,
2503};
2504
2505ccv_cnnp_model_t* ccv_cnnp_pow(const float exponent, const char* const name)
2506{
2507 ccv_cnnp_model_pow_t* const model_pow = (ccv_cnnp_model_pow_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_pow_t));
2508 model_pow->super.isa = &ccv_cnnp_pow_isa;
2509 model_pow->super.input_size = 1;
2510 model_pow->super.outputs = &model_pow->output;
2511 model_pow->super.output_size = 1;
2512 model_pow->params = (ccv_nnc_cmd_param_t){
2513 .size = {
2514 .dim = { 1, 1, 1 }
2515 },
2516 .pow = {
2517 .exponent = exponent,
2518 },
2519 };
2520 ccv_cnnp_model_copy_name(&model_pow->super, name);
2521 return (ccv_cnnp_model_t*)model_pow;
2522}
2523
2524static ccv_cnnp_model_t* _ccv_cnnp_pow_copy(const ccv_cnnp_model_t* const super, void* const context)
2525{
2526 const ccv_cnnp_model_pow_t* const self = (const ccv_cnnp_model_pow_t*)super;
2527 return ccv_cnnp_pow(self->params.pow.exponent, super->name);
2528}
2529
2530// MARK - Sin Layer
2531
2532typedef struct {
2533 ccv_cnnp_model_t super;
2534 ccv_nnc_tensor_symbol_t output;
2535} ccv_cnnp_model_sin_t;
2536
2537static 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)
2538{
2539 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);
2540 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", 2540, __extension__ __PRETTY_FUNCTION__
); }));
2541 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"
, 2541, __extension__ __PRETTY_FUNCTION__); }));
2542 ccv_nnc_tensor_param_t input_params[1];
2543 ccv_nnc_tensor_param_t output_params;
2544 const ccv_nnc_cmd_t sin = CMD_EWSIN_FORWARD()ccv_nnc_cmd(CCV_NNC_EWSIN_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2545 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2546 ccv_nnc_hint_tensor_auto(sin, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2547 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2548 ccv_nnc_graph_exec_symbol_new(graph, sin, inputs, 1, outputs, output_size, "sin");
2549}
2550
2551static ccv_cnnp_model_t* _ccv_cnnp_sin_copy(const ccv_cnnp_model_t* const self, void* const context);
2552
2553static const ccv_cnnp_model_vtab_t ccv_cnnp_sin_isa = {
2554 .build = _ccv_cnnp_sin_build,
2555 .copy = _ccv_cnnp_sin_copy,
2556};
2557
2558ccv_cnnp_model_t* ccv_cnnp_sin(const char* const name)
2559{
2560 ccv_cnnp_model_sin_t* const model_sin = (ccv_cnnp_model_sin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sin_t));
2561 model_sin->super.isa = &ccv_cnnp_sin_isa;
2562 model_sin->super.input_size = 1;
2563 model_sin->super.outputs = &model_sin->output;
2564 model_sin->super.output_size = 1;
2565 ccv_cnnp_model_copy_name(&model_sin->super, name);
2566 return (ccv_cnnp_model_t*)model_sin;
2567}
2568
2569static ccv_cnnp_model_t* _ccv_cnnp_sin_copy(const ccv_cnnp_model_t* const super, void* const context)
2570{
2571 return ccv_cnnp_sin(super->name);
2572}
2573
2574// MARK - Cos Layer
2575
2576typedef struct {
2577 ccv_cnnp_model_t super;
2578 ccv_nnc_tensor_symbol_t output;
2579} ccv_cnnp_model_cos_t;
2580
2581static 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)
2582{
2583 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);
2584 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", 2584, __extension__ __PRETTY_FUNCTION__
); }));
2585 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"
, 2585, __extension__ __PRETTY_FUNCTION__); }));
2586 ccv_nnc_tensor_param_t input_params[1];
2587 ccv_nnc_tensor_param_t output_params;
2588 const ccv_nnc_cmd_t cos = CMD_EWCOS_FORWARD()ccv_nnc_cmd(CCV_NNC_EWCOS_FORWARD, 0, ccv_nnc_cmd_auto, 0);
2589 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2590 ccv_nnc_hint_tensor_auto(cos, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2591 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2592 ccv_nnc_graph_exec_symbol_new(graph, cos, inputs, 1, outputs, output_size, "cos");
2593}
2594
2595static ccv_cnnp_model_t* _ccv_cnnp_cos_copy(const ccv_cnnp_model_t* const self, void* const context);
2596
2597static const ccv_cnnp_model_vtab_t ccv_cnnp_cos_isa = {
2598 .build = _ccv_cnnp_cos_build,
2599 .copy = _ccv_cnnp_cos_copy,
2600};
2601
2602ccv_cnnp_model_t* ccv_cnnp_cos(const char* const name)
2603{
2604 ccv_cnnp_model_cos_t* const model_cos = (ccv_cnnp_model_cos_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cos_t));
2605 model_cos->super.isa = &ccv_cnnp_cos_isa;
2606 model_cos->super.input_size = 1;
2607 model_cos->super.outputs = &model_cos->output;
2608 model_cos->super.output_size = 1;
2609 ccv_cnnp_model_copy_name(&model_cos->super, name);
2610 return (ccv_cnnp_model_t*)model_cos;
2611}
2612
2613static ccv_cnnp_model_t* _ccv_cnnp_cos_copy(const ccv_cnnp_model_t* const super, void* const context)
2614{
2615 return ccv_cnnp_cos(super->name);
2616}
2617
2618// MARK - Rotate Half Layer
2619
2620typedef struct {
2621 ccv_cnnp_model_t super;
2622 ccv_nnc_tensor_symbol_t output;
2623} ccv_cnnp_model_rotate_half_t;
2624
2625static 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)
2626{
2627 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);
2628 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"
, 2628, __extension__ __PRETTY_FUNCTION__); }));
2629 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", 2629, __extension__ __PRETTY_FUNCTION__
); }));
2630 ccv_nnc_tensor_param_t input_params[1];
2631 ccv_nnc_tensor_param_t output_params;
2632 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);
2633 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2634 ccv_nnc_hint_tensor_auto(rotate_half, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2635 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2636 ccv_nnc_graph_exec_symbol_new(graph, rotate_half, inputs, 1, outputs, output_size, "rotate_half");
2637}
2638
2639static ccv_cnnp_model_t* _ccv_cnnp_rotate_half_copy(const ccv_cnnp_model_t* const self, void* const context);
2640
2641static const ccv_cnnp_model_vtab_t ccv_cnnp_rotate_half_isa = {
2642 .build = _ccv_cnnp_rotate_half_build,
2643 .copy = _ccv_cnnp_rotate_half_copy,
2644};
2645
2646ccv_cnnp_model_t* ccv_cnnp_rotate_half(const char* const name)
2647{
2648 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));
2649 model_rotate_half->super.isa = &ccv_cnnp_rotate_half_isa;
2650 model_rotate_half->super.input_size = 1;
2651 model_rotate_half->super.outputs = &model_rotate_half->output;
2652 model_rotate_half->super.output_size = 1;
2653 ccv_cnnp_model_copy_name(&model_rotate_half->super, name);
2654 return (ccv_cnnp_model_t*)model_rotate_half;
2655}
2656
2657static ccv_cnnp_model_t* _ccv_cnnp_rotate_half_copy(const ccv_cnnp_model_t* const super, void* const context)
2658{
2659 return ccv_cnnp_rotate_half(super->name);
2660}
2661
2662// MARK - Walsh-Hadamard Transform Layer
2663
2664typedef struct {
2665 ccv_cnnp_model_t super;
2666 ccv_nnc_tensor_symbol_t output;
2667 float scale;
2668} ccv_cnnp_model_walsh_hadamard_transform_t;
2669
2670static 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)
2671{
2672 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);
2673 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"
, 2673, __extension__ __PRETTY_FUNCTION__); }));
2674 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", 2674, __extension__ __PRETTY_FUNCTION__
); }));
2675 const ccv_cnnp_model_walsh_hadamard_transform_t* const self = (const ccv_cnnp_model_walsh_hadamard_transform_t*)super;
2676 ccv_nnc_tensor_param_t input_params[1];
2677 ccv_nnc_tensor_param_t output_params;
2678 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);
2679 input_params[0] = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2680 ccv_nnc_hint_tensor_auto(walsh_hadamard_transform, input_params, 1, ccv_nnc_no_hint, &output_params, 1);
2681 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2682 ccv_nnc_graph_exec_symbol_new(graph, walsh_hadamard_transform, inputs, 1, outputs, output_size, "walsh_hadamard_transform");
2683}
2684
2685static ccv_cnnp_model_t* _ccv_cnnp_walsh_hadamard_transform_copy(const ccv_cnnp_model_t* const self, void* const context);
2686
2687static const ccv_cnnp_model_vtab_t ccv_cnnp_walsh_hadamard_transform_isa = {
2688 .build = _ccv_cnnp_walsh_hadamard_transform_build,
2689 .copy = _ccv_cnnp_walsh_hadamard_transform_copy,
2690};
2691
2692ccv_cnnp_model_t* ccv_cnnp_walsh_hadamard_transform(const float scale, const char* const name)
2693{
2694 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));
2695 model_walsh_hadamard_transform->super.isa = &ccv_cnnp_walsh_hadamard_transform_isa;
2696 model_walsh_hadamard_transform->super.input_size = 1;
2697 model_walsh_hadamard_transform->super.outputs = &model_walsh_hadamard_transform->output;
2698 model_walsh_hadamard_transform->super.output_size = 1;
2699 model_walsh_hadamard_transform->scale = scale;
2700 ccv_cnnp_model_copy_name(&model_walsh_hadamard_transform->super, name);
2701 return (ccv_cnnp_model_t*)model_walsh_hadamard_transform;
2702}
2703
2704static ccv_cnnp_model_t* _ccv_cnnp_walsh_hadamard_transform_copy(const ccv_cnnp_model_t* const super, void* const context)
2705{
2706 const ccv_cnnp_model_walsh_hadamard_transform_t* const self = (const ccv_cnnp_model_walsh_hadamard_transform_t*)super;
2707 return ccv_cnnp_walsh_hadamard_transform(self->scale, self->super.name);
2708}
2709
2710// MARK - Hyper Connection Layer
2711
2712typedef struct {
2713 ccv_cnnp_model_t super;
2714 ccv_nnc_tensor_symbol_t outputs[4];
2715 int count;
2716 int sinkhorn_iterations;
2717 float epsilon;
2718 float norm_epsilon;
2719 int operation;
2720} ccv_cnnp_model_hyper_connection_t;
2721
2722static 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)
2723{
2724 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);
2725 const ccv_cnnp_model_hyper_connection_t* const self = (const ccv_cnnp_model_hyper_connection_t*)super;
2726 assert(input_size == (self->operation == 0 ? 3 : self->operation == 3 ? 6 : self->operation == 4 || self->operation == 5 ? 5 : 4))((void) sizeof ((input_size == (self->operation == 0 ? 3 :
self->operation == 3 ? 6 : self->operation == 4 || self
->operation == 5 ? 5 : 4)) ? 1 : 0), __extension__ ({ if (
input_size == (self->operation == 0 ? 3 : self->operation
== 3 ? 6 : self->operation == 4 || self->operation == 5
? 5 : 4)) ; else __assert_fail ("input_size == (self->operation == 0 ? 3 : self->operation == 3 ? 6 : self->operation == 4 || self->operation == 5 ? 5 : 4)"
, "ccv_cnnp_model_addons.c", 2726, __extension__ __PRETTY_FUNCTION__
); }));
2727 assert(output_size == (self->operation == 2 || self->operation == 4 ? 1 : self->operation == 3 || self->operation == 5 ? 4 : 3))((void) sizeof ((output_size == (self->operation == 2 || self
->operation == 4 ? 1 : self->operation == 3 || self->
operation == 5 ? 4 : 3)) ? 1 : 0), __extension__ ({ if (output_size
== (self->operation == 2 || self->operation == 4 ? 1 :
self->operation == 3 || self->operation == 5 ? 4 : 3))
; else __assert_fail ("output_size == (self->operation == 2 || self->operation == 4 ? 1 : self->operation == 3 || self->operation == 5 ? 4 : 3)"
, "ccv_cnnp_model_addons.c", 2727, __extension__ __PRETTY_FUNCTION__
); }));
2728 ccv_nnc_tensor_param_t input_params[6];
2729 int i;
2730 for (i = 0; i < input_size; i++)
2731 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2732 ccv_nnc_tensor_param_t output_params[4];
2733 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);
2734 hyper_connection.info.hyper_connection.norm_epsilon = self->norm_epsilon;
2735 ccv_nnc_hint_tensor_auto(hyper_connection, input_params, input_size, ccv_nnc_no_hint, output_params, output_size);
2736 for (i = 0; i < output_size; i++)
2737 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
2738 ccv_nnc_graph_exec_symbol_new(graph, hyper_connection, inputs, input_size, outputs, output_size, "hyper_connection");
2739}
2740
2741static ccv_cnnp_model_t* _ccv_cnnp_hyper_connection_copy(const ccv_cnnp_model_t* const self, void* const context);
2742
2743static const ccv_cnnp_model_vtab_t ccv_cnnp_hyper_connection_isa = {
2744 .build = _ccv_cnnp_hyper_connection_build,
2745 .copy = _ccv_cnnp_hyper_connection_copy,
2746};
2747
2748ccv_cnnp_model_t* ccv_cnnp_hyper_connection(const int count, const int sinkhorn_iterations, const float epsilon, const float norm_epsilon, const int operation, const char* const name)
2749{
2750 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", 2750, __extension__ __PRETTY_FUNCTION__
); }));
2751 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", 2751, __extension__ __PRETTY_FUNCTION__
); }));
2752 assert(epsilon >= 0)((void) sizeof ((epsilon >= 0) ? 1 : 0), __extension__ ({ if
(epsilon >= 0) ; else __assert_fail ("epsilon >= 0", "ccv_cnnp_model_addons.c"
, 2752, __extension__ __PRETTY_FUNCTION__); }));
2753 assert(operation >= 0 && operation <= 5)((void) sizeof ((operation >= 0 && operation <=
5) ? 1 : 0), __extension__ ({ if (operation >= 0 &&
operation <= 5) ; else __assert_fail ("operation >= 0 && operation <= 5"
, "ccv_cnnp_model_addons.c", 2753, __extension__ __PRETTY_FUNCTION__
); }));
2754 assert((operation != 3 && operation != 5) || norm_epsilon > 0)((void) sizeof (((operation != 3 && operation != 5) ||
norm_epsilon > 0) ? 1 : 0), __extension__ ({ if ((operation
!= 3 && operation != 5) || norm_epsilon > 0) ; else
__assert_fail ("(operation != 3 && operation != 5) || norm_epsilon > 0"
, "ccv_cnnp_model_addons.c", 2754, __extension__ __PRETTY_FUNCTION__
); }));
2755 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));
2756 model_hyper_connection->super.isa = &ccv_cnnp_hyper_connection_isa;
2757 model_hyper_connection->super.input_size = operation == 0 ? 3 : operation == 3 ? 6 : operation == 4 || operation == 5 ? 5 : 4;
2758 model_hyper_connection->super.outputs = model_hyper_connection->outputs;
2759 model_hyper_connection->super.output_size = operation == 2 || operation == 4 ? 1 : operation == 3 || operation == 5 ? 4 : 3;
2760 model_hyper_connection->count = count;
2761 model_hyper_connection->sinkhorn_iterations = sinkhorn_iterations;
2762 model_hyper_connection->epsilon = epsilon;
2763 model_hyper_connection->norm_epsilon = norm_epsilon;
2764 model_hyper_connection->operation = operation;
2765 ccv_cnnp_model_copy_name(&model_hyper_connection->super, name);
2766 return (ccv_cnnp_model_t*)model_hyper_connection;
2767}
2768
2769static ccv_cnnp_model_t* _ccv_cnnp_hyper_connection_copy(const ccv_cnnp_model_t* const super, void* const context)
2770{
2771 const ccv_cnnp_model_hyper_connection_t* const self = (const ccv_cnnp_model_hyper_connection_t*)super;
2772 return ccv_cnnp_hyper_connection(self->count, self->sinkhorn_iterations, self->epsilon, self->norm_epsilon, self->operation, self->super.name);
2773}
2774
2775// MARK - Causal Convolution Layer
2776
2777typedef struct {
2778 ccv_cnnp_model_t super;
2779 ccv_nnc_tensor_symbol_t outputs[2];
2780 ccv_nnc_tensor_symbol_t weights;
2781 int kernel_size;
2782 int silu;
2783 int state_checkpoint_count;
2784} ccv_cnnp_model_causal_convolution_t;
2785
2786static void _ccv_cnnp_causal_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)
2787{
2788 PRINT(CCV_CLI_VERBOSE, "[cnnp_causal_convolution_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_causal_convolution_build] -\n"); fflush(stdout
); } } while (0);
2789 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"
, 2789, __extension__ __PRETTY_FUNCTION__); }));
2790 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", 2790, __extension__ __PRETTY_FUNCTION__
); }));
2791 ccv_cnnp_model_causal_convolution_t* const self = (ccv_cnnp_model_causal_convolution_t*)super;
2792 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
2793 const int channels = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
2794 // The depthwise convolution's weight layout, so its checkpoints load as they are.
2795 ccv_nnc_tensor_param_t weights_params = params;
2796 memset(weights_params.dim, 0, sizeof(weights_params.dim));
2797 weights_params.format = CCV_TENSOR_FORMAT_NCHW;
2798 weights_params.dim[0] = channels;
2799 weights_params.dim[1] = 1;
2800 weights_params.dim[2] = self->kernel_size;
2801 weights_params.dim[3] = 1;
2802 if (!self->weights.graph)
2803 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
2804 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
2805 const ccv_nnc_cmd_t cmd = CMD_CAUSAL_CONVOLUTION_FORWARD(self->silu, self->state_checkpoint_count)ccv_nnc_cmd(CCV_NNC_CAUSAL_CONVOLUTION_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.causal_convolution={.silu=(self->silu
),.state_checkpoint_count=(self->state_checkpoint_count)}}
), 0);
2806 ccv_nnc_tensor_param_t output_params[2];
2807 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
2808 params,
2809 ccv_nnc_tensor_symbol_params(graph, inputs[1]),
2810 weights_params,
2811 }, 3, ccv_nnc_no_hint, output_params, 2);
2812 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
2813 outputs[1] = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
2814 ccv_nnc_graph_exec_symbol_new(graph, cmd, TENSOR_SYMBOL_LIST(inputs[0], inputs[1], weights)(const ccv_nnc_tensor_symbol_t []){inputs[0], inputs[1], weights
}, (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, "causal_convolution");
2815}
2816
2817static void _ccv_cnnp_causal_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)
2818{
2819 ccv_cnnp_model_causal_convolution_t* const self = (ccv_cnnp_model_causal_convolution_t*)super;
2820 // Each channel's fan-in is its taps.
2821 const float bound = sqrtf(3) * sqrtf(2) / sqrtf(self->kernel_size);
2822 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);
2823}
2824
2825static void _ccv_cnnp_causal_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)
2826{
2827 ccv_cnnp_model_causal_convolution_t* const self = (ccv_cnnp_model_causal_convolution_t*)super;
2828 add_to_array(parameters, self->weights, is_trainable);
2829}
2830
2831static ccv_cnnp_model_t* _ccv_cnnp_causal_convolution_copy(const ccv_cnnp_model_t* const self, void* const context);
2832
2833static const ccv_cnnp_model_vtab_t ccv_cnnp_causal_convolution_isa = {
2834 .build = _ccv_cnnp_causal_convolution_build,
2835 .init_states = _ccv_cnnp_causal_convolution_init_states,
2836 .add_to_parameter = _ccv_cnnp_causal_convolution_add_to_parameter,
2837 .copy = _ccv_cnnp_causal_convolution_copy,
2838};
2839
2840ccv_cnnp_model_t* ccv_cnnp_causal_convolution(const int kernel_size, const int silu, const int state_checkpoint_count, const int is_trainable, const char* const name)
2841{
2842 // One tap has no previous rows to carry.
2843 assert(kernel_size >= 2)((void) sizeof ((kernel_size >= 2) ? 1 : 0), __extension__
({ if (kernel_size >= 2) ; else __assert_fail ("kernel_size >= 2"
, "ccv_cnnp_model_addons.c", 2843, __extension__ __PRETTY_FUNCTION__
); }));
2844 ccv_cnnp_model_causal_convolution_t* const model_causal_convolution = (ccv_cnnp_model_causal_convolution_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_causal_convolution_t));
2845 model_causal_convolution->super.isa = &ccv_cnnp_causal_convolution_isa;
2846 model_causal_convolution->super.input_size = 2;
2847 model_causal_convolution->super.outputs = model_causal_convolution->outputs;
2848 model_causal_convolution->super.output_size = 2;
2849 model_causal_convolution->super.is_trainable = is_trainable;
2850 model_causal_convolution->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
2851 model_causal_convolution->weights.graph = 0;
2852 model_causal_convolution->kernel_size = kernel_size;
2853 model_causal_convolution->silu = silu;
2854 model_causal_convolution->state_checkpoint_count = state_checkpoint_count;
2855 ccv_cnnp_model_copy_name(&model_causal_convolution->super, name);
2856 return (ccv_cnnp_model_t*)model_causal_convolution;
2857}
2858
2859static ccv_cnnp_model_t* _ccv_cnnp_causal_convolution_copy(const ccv_cnnp_model_t* const super, void* const context)
2860{
2861 const ccv_cnnp_model_causal_convolution_t* const self = (const ccv_cnnp_model_causal_convolution_t*)super;
2862 return ccv_cnnp_causal_convolution(self->kernel_size, self->silu, self->state_checkpoint_count, self->super.is_trainable, super->name);
2863}
2864
2865// MARK - Gated Delta Layer
2866
2867typedef struct {
2868 ccv_cnnp_model_t super;
2869 ccv_nnc_tensor_symbol_t outputs[2];
2870 int log_decay;
2871 int state_checkpoint_count;
2872 int qk_l2norm;
2873 float q_scale;
2874 int sigmoid_gate;
2875 float gate_lower_bound;
2876 int sigmoid_beta;
2877} ccv_cnnp_model_gated_delta_t;
2878
2879static 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)
2880{
2881 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);
2882 ccv_cnnp_model_gated_delta_t* const self = (ccv_cnnp_model_gated_delta_t*)super;
2883 assert(input_size == (self->sigmoid_gate ? 8 : 6))((void) sizeof ((input_size == (self->sigmoid_gate ? 8 : 6
)) ? 1 : 0), __extension__ ({ if (input_size == (self->sigmoid_gate
? 8 : 6)) ; else __assert_fail ("input_size == (self->sigmoid_gate ? 8 : 6)"
, "ccv_cnnp_model_addons.c", 2883, __extension__ __PRETTY_FUNCTION__
); }));
2884 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", 2884, __extension__ __PRETTY_FUNCTION__
); }));
2885 ccv_nnc_tensor_param_t input_params[8];
2886 int i;
2887 for (i = 0; i < input_size; i++)
2888 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2889 ccv_nnc_tensor_param_t output_params[2];
2890 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);
2891 gated_delta.info.gated_delta.qk_l2norm = self->qk_l2norm;
2892 gated_delta.info.gated_delta.q_scale = self->q_scale;
2893 gated_delta.info.gated_delta.sigmoid_gate = self->sigmoid_gate;
2894 gated_delta.info.gated_delta.gate_lower_bound = self->gate_lower_bound;
2895 gated_delta.info.gated_delta.sigmoid_beta = self->sigmoid_beta;
2896 ccv_nnc_hint_tensor_auto(gated_delta, input_params, input_size, ccv_nnc_no_hint, output_params, 2);
2897 for (i = 0; i < 2; i++)
2898 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
2899 ccv_nnc_graph_exec_symbol_new(graph, gated_delta, inputs, input_size, outputs, output_size, "gated_delta");
2900}
2901
2902static ccv_cnnp_model_t* _ccv_cnnp_gated_delta_copy(const ccv_cnnp_model_t* const self, void* const context);
2903
2904static const ccv_cnnp_model_vtab_t ccv_cnnp_gated_delta_isa = {
2905 .build = _ccv_cnnp_gated_delta_build,
2906 .copy = _ccv_cnnp_gated_delta_copy,
2907};
2908
2909ccv_cnnp_model_t* ccv_cnnp_gated_delta(const int log_decay, const int state_checkpoint_count, const int qk_l2norm, const float q_scale, const int sigmoid_gate, const float gate_lower_bound, const int sigmoid_beta, const char* const name)
2910{
2911 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));
2912 model_gated_delta->super.isa = &ccv_cnnp_gated_delta_isa;
2913 model_gated_delta->super.input_size = sigmoid_gate ? 8 : 6;
2914 model_gated_delta->super.outputs = model_gated_delta->outputs;
2915 model_gated_delta->super.output_size = 2;
2916 model_gated_delta->log_decay = log_decay;
2917 model_gated_delta->state_checkpoint_count = state_checkpoint_count;
2918 model_gated_delta->qk_l2norm = qk_l2norm;
2919 model_gated_delta->q_scale = q_scale;
2920 model_gated_delta->sigmoid_gate = sigmoid_gate;
2921 model_gated_delta->gate_lower_bound = gate_lower_bound;
2922 model_gated_delta->sigmoid_beta = sigmoid_beta;
2923 ccv_cnnp_model_copy_name(&model_gated_delta->super, name);
2924 return (ccv_cnnp_model_t*)model_gated_delta;
2925}
2926
2927static ccv_cnnp_model_t* _ccv_cnnp_gated_delta_copy(const ccv_cnnp_model_t* const super, void* const context)
2928{
2929 const ccv_cnnp_model_gated_delta_t* const self = (const ccv_cnnp_model_gated_delta_t*)super;
2930 return ccv_cnnp_gated_delta(self->log_decay, self->state_checkpoint_count, self->qk_l2norm, self->q_scale, self->sigmoid_gate, self->gate_lower_bound, self->sigmoid_beta, super->name);
2931}
2932
2933// MARK - Cmul Layer
2934
2935typedef struct {
2936 ccv_cnnp_model_t super;
2937 ccv_nnc_tensor_symbol_t output;
2938 int conjugate;
2939} ccv_cnnp_model_cmul_t;
2940
2941static 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)
2942{
2943 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);
2944 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"
, 2944, __extension__ __PRETTY_FUNCTION__); }));
2945 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", 2945, __extension__ __PRETTY_FUNCTION__
); }));
2946 ccv_nnc_tensor_param_t input_params[2];
2947 int i;
2948 for (i = 0; i < 2; i++)
2949 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
2950 ccv_nnc_tensor_param_t output_params;
2951 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);
2952 mul.info.cmul.conjugate = ((ccv_cnnp_model_cmul_t*)super)->conjugate;
2953 ccv_nnc_hint_tensor_auto(mul, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
2954 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
2955 ccv_nnc_graph_exec_symbol_new(graph, mul, inputs, input_size, outputs, output_size, "cmul");
2956}
2957
2958static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const self, void* const context);
2959
2960static const ccv_cnnp_model_vtab_t ccv_cnnp_cmul_isa = {
2961 .build = _ccv_cnnp_cmul_build,
2962 .copy = _ccv_cnnp_cmul_copy,
2963};
2964
2965ccv_cnnp_model_t* ccv_cnnp_cmul(const int conjugate, const char* const name)
2966{
2967 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"
, 2967, __extension__ __PRETTY_FUNCTION__); }));
2968 ccv_cnnp_model_cmul_t* const model_cmul = (ccv_cnnp_model_cmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_cmul_t));
2969 model_cmul->super.isa = &ccv_cnnp_cmul_isa;
2970 model_cmul->super.input_size = 2;
2971 model_cmul->super.outputs = &model_cmul->output;
2972 model_cmul->super.output_size = 1;
2973 model_cmul->conjugate = conjugate;
2974 ccv_cnnp_model_copy_name(&model_cmul->super, name);
2975 return (ccv_cnnp_model_t*)model_cmul;
2976}
2977
2978static ccv_cnnp_model_t* _ccv_cnnp_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
2979{
2980 const ccv_cnnp_model_cmul_t* const self = (const ccv_cnnp_model_cmul_t*)super;
2981 return ccv_cnnp_cmul(self->conjugate, super->name);
2982}
2983
2984// MARK - Transpose Layer
2985
2986typedef struct {
2987 ccv_cnnp_model_t super;
2988 ccv_nnc_tensor_symbol_t output;
2989 int transpose[2];
2990} ccv_cnnp_model_transpose_t;
2991
2992static 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)
2993{
2994 ccv_cnnp_model_transpose_t* const self = (ccv_cnnp_model_transpose_t*)super;
2995 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);
2996 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"
, 2996, __extension__ __PRETTY_FUNCTION__); }));
2997 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", 2997, __extension__ __PRETTY_FUNCTION__
); }));
2998 if (self->transpose[0] == self->transpose[1])
2999 {
3000 outputs[0] = inputs[0];
3001 return;
3002 }
3003 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3004 ccv_nnc_tensor_param_t output_params;
3005 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);
3006 ccv_nnc_hint_tensor_auto(transpose, (ccv_nnc_tensor_param_t []){
3007 params,
3008 }, 1, ccv_nnc_no_hint, &output_params, 1);
3009 const ccv_nnc_tensor_symbol_t transpose_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3010 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");
3011 outputs[0] = transpose_output;
3012}
3013
3014static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context);
3015
3016static const ccv_cnnp_model_vtab_t ccv_cnnp_transpose_isa = {
3017 .build = _ccv_cnnp_transpose_build,
3018 .copy = _ccv_cnnp_transpose_copy,
3019};
3020
3021ccv_cnnp_model_t* ccv_cnnp_transpose(const int axis_a, const int axis_b, const char* const name)
3022{
3023 ccv_cnnp_model_transpose_t* const model_transpose = (ccv_cnnp_model_transpose_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_transpose_t));
3024 model_transpose->super.isa = &ccv_cnnp_transpose_isa;
3025 model_transpose->super.input_size = 1;
3026 model_transpose->super.outputs = &model_transpose->output;
3027 model_transpose->super.output_size = 1;
3028 model_transpose->transpose[0] = axis_a;
3029 model_transpose->transpose[1] = axis_b;
3030 ccv_cnnp_model_copy_name(&model_transpose->super, name);
3031 return (ccv_cnnp_model_t*)model_transpose;
3032}
3033
3034static ccv_cnnp_model_t* _ccv_cnnp_transpose_copy(const ccv_cnnp_model_t* const super, void* const context)
3035{
3036 const ccv_cnnp_model_transpose_t* const self = (const ccv_cnnp_model_transpose_t*)super;
3037 return ccv_cnnp_transpose(self->transpose[0], self->transpose[1], self->super.name);
3038}
3039
3040// MARK - Layer Norm Layer
3041
3042typedef struct {
3043 ccv_cnnp_model_t super;
3044 ccv_nnc_tensor_symbol_t output;
3045 ccv_nnc_tensor_symbol_t bias;
3046 ccv_nnc_tensor_symbol_t scale;
3047 ccv_nnc_cmd_param_t params;
3048} ccv_cnnp_model_layer_norm_t;
3049
3050static 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)
3051{
3052 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);
3053 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"
, 3053, __extension__ __PRETTY_FUNCTION__); }));
3054 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", 3054, __extension__ __PRETTY_FUNCTION__
); }));
3055 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
3056 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3057 ccv_nnc_tensor_param_t bias_params = params;
3058 const int nd = ccv_nnc_tensor_nd(params.dim);
3059 int i;
3060 for (i = 0; i < nd; i++)
3061 bias_params.dim[i] = 1;
3062 for (i = 0; i < self->params.lnorm.count; i++)
3063 bias_params.dim[self->params.lnorm.axis[i]] = params.dim[self->params.lnorm.axis[i]];
3064 if (self->params.lnorm.elementwise_affine)
3065 {
3066 // Both scale and bias are shared between if this model is reused.
3067 if (!self->scale.graph)
3068 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
3069 if (!self->bias.graph)
3070 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
3071 }
3072 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
};
3073 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
};
3074 const ccv_nnc_cmd_t layer_norm = ccv_nnc_cmd(CCV_NNC_LAYER_NORM_FORWARD, 0, self->params, 0);
3075 ccv_nnc_tensor_param_t output_params[3];
3076 if (self->params.lnorm.elementwise_affine)
3077 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
3078 params,
3079 bias_params,
3080 bias_params,
3081 }, 3, ccv_nnc_no_hint, output_params, 3);
3082 else
3083 ccv_nnc_hint_tensor_auto(layer_norm, (ccv_nnc_tensor_param_t []){
3084 params,
3085 }, 1, ccv_nnc_no_hint, output_params, 3);
3086 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3087 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
3088 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
3089 if (self->params.lnorm.elementwise_affine)
3090 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");
3091 else
3092 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");
3093 outputs[0] = output;
3094}
3095
3096static 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)
3097{
3098 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
3099 if (self->scale.graph)
3100 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);
3101 if (self->bias.graph)
3102 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);
3103}
3104
3105static 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)
3106{
3107 ccv_cnnp_model_layer_norm_t* const self = (ccv_cnnp_model_layer_norm_t*)super;
3108 if (self->scale.graph)
3109 add_to_array(parameters, self->scale, is_trainable);
3110 if (self->bias.graph)
3111 add_to_array(parameters, self->bias, is_trainable);
3112}
3113
3114static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
3115
3116static const ccv_cnnp_model_vtab_t ccv_cnnp_layer_norm_isa = {
3117 .build = _ccv_cnnp_layer_norm_build,
3118 .init_states = _ccv_cnnp_layer_norm_init_states,
3119 .add_to_parameter = _ccv_cnnp_layer_norm_add_to_parameter,
3120 .copy = _ccv_cnnp_layer_norm_copy,
3121};
3122
3123ccv_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)
3124{
3125 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));
3126 model_layer_norm->super.isa = &ccv_cnnp_layer_norm_isa;
3127 model_layer_norm->super.input_size = 1;
3128 model_layer_norm->super.outputs = &model_layer_norm->output;
3129 model_layer_norm->super.output_size = 1;
3130 model_layer_norm->super.is_trainable = is_trainable;
3131 ccv_cnnp_model_copy_name(&model_layer_norm->super, name);
3132 model_layer_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3133 model_layer_norm->scale.graph = 0;
3134 model_layer_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
3135 model_layer_norm->bias.graph = 0;
3136 model_layer_norm->params.lnorm.epsilon = epsilon;
3137 model_layer_norm->params.lnorm.scale = scale;
3138 model_layer_norm->params.lnorm.count = axis_count;
3139 model_layer_norm->params.lnorm.elementwise_affine = elementwise_affine;
3140 memcpy(model_layer_norm->params.lnorm.axis, axis, sizeof(int) * axis_count);
3141 return (ccv_cnnp_model_t*)model_layer_norm;
3142}
3143
3144static ccv_cnnp_model_t* _ccv_cnnp_layer_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
3145{
3146 const ccv_cnnp_model_layer_norm_t* const self = (const ccv_cnnp_model_layer_norm_t*)super;
3147 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);
3148}
3149
3150// MARK - Group Norm Layer
3151
3152typedef struct {
3153 ccv_cnnp_model_t super;
3154 ccv_nnc_tensor_symbol_t output;
3155 ccv_nnc_tensor_symbol_t bias;
3156 ccv_nnc_tensor_symbol_t scale;
3157 ccv_nnc_cmd_param_t params;
3158} ccv_cnnp_model_group_norm_t;
3159
3160static 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)
3161{
3162 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);
3163 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"
, 3163, __extension__ __PRETTY_FUNCTION__); }));
3164 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", 3164, __extension__ __PRETTY_FUNCTION__
); }));
3165 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
3166 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3167 ccv_nnc_tensor_param_t bias_params = params;
3168 const int nd = ccv_nnc_tensor_nd(params.dim);
3169 int i;
3170 for (i = 0; i < nd; i++)
3171 bias_params.dim[i] = 1;
3172 bias_params.dim[self->params.gnorm.group_axis] = params.dim[self->params.gnorm.group_axis];
3173 if (self->params.gnorm.elementwise_affine)
3174 {
3175 // Both scale and bias are shared between if this model is reused.
3176 if (!self->scale.graph)
3177 self->scale = ccv_nnc_tensor_symbol_new(graph, bias_params, "scale");
3178 if (!self->bias.graph)
3179 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
3180 }
3181 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
};
3182 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
};
3183 const ccv_nnc_cmd_t group_norm = ccv_nnc_cmd(CCV_NNC_GROUP_NORM_FORWARD, 0, self->params, 0);
3184 ccv_nnc_tensor_param_t output_params[3];
3185 if (self->params.gnorm.elementwise_affine)
3186 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
3187 params,
3188 bias_params,
3189 bias_params,
3190 }, 3, ccv_nnc_no_hint, output_params, 3);
3191 else
3192 ccv_nnc_hint_tensor_auto(group_norm, (ccv_nnc_tensor_param_t []){
3193 params,
3194 }, 1, ccv_nnc_no_hint, output_params, 3);
3195 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3196 const ccv_nnc_tensor_symbol_t saved_mean = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_mean");
3197 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[2], "saved_inv_std");
3198 if (self->params.gnorm.elementwise_affine)
3199 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");
3200 else
3201 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");
3202 outputs[0] = output;
3203}
3204
3205static 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)
3206{
3207 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
3208 if (self->scale.graph)
3209 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);
3210 if (self->bias.graph)
3211 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);
3212}
3213
3214static 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)
3215{
3216 ccv_cnnp_model_group_norm_t* const self = (ccv_cnnp_model_group_norm_t*)super;
3217 if (self->scale.graph)
3218 add_to_array(parameters, self->scale, is_trainable);
3219 if (self->bias.graph)
3220 add_to_array(parameters, self->bias, is_trainable);
3221}
3222
3223static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context);
3224
3225static const ccv_cnnp_model_vtab_t ccv_cnnp_group_norm_isa = {
3226 .build = _ccv_cnnp_group_norm_build,
3227 .init_states = _ccv_cnnp_group_norm_init_states,
3228 .add_to_parameter = _ccv_cnnp_group_norm_add_to_parameter,
3229 .copy = _ccv_cnnp_group_norm_copy,
3230};
3231
3232ccv_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)
3233{
3234 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));
3235 model_group_norm->super.isa = &ccv_cnnp_group_norm_isa;
3236 model_group_norm->super.input_size = 1;
3237 model_group_norm->super.outputs = &model_group_norm->output;
3238 model_group_norm->super.output_size = 1;
3239 model_group_norm->super.is_trainable = is_trainable;
3240 ccv_cnnp_model_copy_name(&model_group_norm->super, name);
3241 model_group_norm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3242 model_group_norm->scale.graph = 0;
3243 model_group_norm->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
3244 model_group_norm->bias.graph = 0;
3245 model_group_norm->params.gnorm.group_axis = group_axis;
3246 model_group_norm->params.gnorm.groups = groups;
3247 model_group_norm->params.gnorm.epsilon = epsilon;
3248 model_group_norm->params.gnorm.reduce_count = axis_count;
3249 model_group_norm->params.gnorm.elementwise_affine = elementwise_affine;
3250 memcpy(model_group_norm->params.gnorm.reduce_axis, reduce_axis, sizeof(int) * axis_count);
3251 return (ccv_cnnp_model_t*)model_group_norm;
3252}
3253
3254static ccv_cnnp_model_t* _ccv_cnnp_group_norm_copy(const ccv_cnnp_model_t* const super, void* const context)
3255{
3256 const ccv_cnnp_model_group_norm_t* const self = (const ccv_cnnp_model_group_norm_t*)super;
3257 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);
3258}
3259
3260// MARK - RMSNorm Layer
3261
3262typedef struct {
3263 ccv_cnnp_model_t super;
3264 ccv_nnc_tensor_symbol_t output;
3265 ccv_nnc_tensor_symbol_t scale;
3266 ccv_nnc_cmd_param_t params;
3267} ccv_cnnp_model_rmsnorm_t;
3268
3269static 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)
3270{
3271 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);
3272 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"
, 3272, __extension__ __PRETTY_FUNCTION__); }));
3273 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", 3273, __extension__ __PRETTY_FUNCTION__
); }));
3274 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3275 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3276 ccv_nnc_tensor_param_t scale_params = params;
3277 const int nd = ccv_nnc_tensor_nd(params.dim);
3278 int i;
3279 for (i = 0; i < nd; i++)
3280 scale_params.dim[i] = 1;
3281 for (i = 0; i < self->params.rmsnorm.count; i++)
3282 scale_params.dim[self->params.rmsnorm.axis[i]] = params.dim[self->params.rmsnorm.axis[i]];
3283 // Both scale and bias are shared between if this model is reused.
3284 if (self->params.rmsnorm.elementwise_affine)
3285 {
3286 if (!self->scale.graph)
3287 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3288 }
3289 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
};
3290 const ccv_nnc_cmd_t rmsnorm = ccv_nnc_cmd(CCV_NNC_RMSNORM_FORWARD, 0, self->params, 0);
3291 ccv_nnc_tensor_param_t output_params[2];
3292 if (self->params.rmsnorm.elementwise_affine)
3293 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
3294 params,
3295 scale_params,
3296 }, 2, ccv_nnc_no_hint, output_params, 2);
3297 else
3298 ccv_nnc_hint_tensor_auto(rmsnorm, (ccv_nnc_tensor_param_t []){
3299 params,
3300 }, 1, ccv_nnc_no_hint, output_params, 2);
3301 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3302 const ccv_nnc_tensor_symbol_t saved_inv_std = ccv_nnc_tensor_symbol_new(graph, output_params[1], "saved_inv_std");
3303 if (self->params.rmsnorm.elementwise_affine)
3304 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");
3305 else
3306 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");
3307 outputs[0] = output;
3308}
3309
3310static 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)
3311{
3312 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3313 if (self->scale.graph)
3314 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);
3315}
3316
3317static 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)
3318{
3319 ccv_cnnp_model_rmsnorm_t* const self = (ccv_cnnp_model_rmsnorm_t*)super;
3320 if (self->scale.graph)
3321 add_to_array(parameters, self->scale, is_trainable);
3322}
3323
3324static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context);
3325
3326static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_isa = {
3327 .build = _ccv_cnnp_rmsnorm_build,
3328 .init_states = _ccv_cnnp_rmsnorm_init_states,
3329 .add_to_parameter = _ccv_cnnp_rmsnorm_add_to_parameter,
3330 .copy = _ccv_cnnp_rmsnorm_copy,
3331};
3332
3333ccv_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)
3334{
3335 ccv_cnnp_model_rmsnorm_t* const model_rmsnorm = (ccv_cnnp_model_rmsnorm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_rmsnorm_t));
3336 model_rmsnorm->super.isa = &ccv_cnnp_rmsnorm_isa;
3337 model_rmsnorm->super.input_size = 1;
3338 model_rmsnorm->super.outputs = &model_rmsnorm->output;
3339 model_rmsnorm->super.output_size = 1;
3340 model_rmsnorm->super.is_trainable = is_trainable;
3341 ccv_cnnp_model_copy_name(&model_rmsnorm->super, name);
3342 model_rmsnorm->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3343 model_rmsnorm->scale.graph = 0;
3344 model_rmsnorm->params.rmsnorm.epsilon = epsilon;
3345 model_rmsnorm->params.rmsnorm.scale = scale;
3346 model_rmsnorm->params.rmsnorm.count = axis_count;
3347 model_rmsnorm->params.rmsnorm.elementwise_affine = elementwise_affine;
3348 memcpy(model_rmsnorm->params.lnorm.axis, axis, sizeof(int) * axis_count);
3349 return (ccv_cnnp_model_t*)model_rmsnorm;
3350}
3351
3352static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_copy(const ccv_cnnp_model_t* const super, void* const context)
3353{
3354 const ccv_cnnp_model_rmsnorm_t* const self = (const ccv_cnnp_model_rmsnorm_t*)super;
3355 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);
3356}
3357
3358// MARK - RMSNorm CMul Layer
3359
3360typedef struct {
3361 ccv_cnnp_model_t super;
3362 ccv_nnc_tensor_symbol_t output;
3363 ccv_nnc_tensor_symbol_t scale;
3364 ccv_nnc_cmd_param_t params;
3365} ccv_cnnp_model_rmsnorm_cmul_t;
3366
3367static 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)
3368{
3369 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);
3370 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"
, 3370, __extension__ __PRETTY_FUNCTION__); }));
3371 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", 3371, __extension__ __PRETTY_FUNCTION__
); }));
3372 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3373 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3374 const ccv_nnc_tensor_param_t rotation_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3375 ccv_nnc_tensor_param_t scale_params = params;
3376 const int nd = ccv_nnc_tensor_nd(params.dim);
3377 int i;
3378 for (i = 0; i < nd; i++)
3379 scale_params.dim[i] = 1;
3380 for (i = 0; i < self->params.rmsnorm_cmul.count; i++)
3381 scale_params.dim[self->params.rmsnorm_cmul.axis[i]] = params.dim[self->params.rmsnorm_cmul.axis[i]];
3382 if (self->params.rmsnorm_cmul.elementwise_affine)
3383 {
3384 if (!self->scale.graph)
3385 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3386 }
3387 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
};
3388 const ccv_nnc_cmd_t rmsnorm_cmul = ccv_nnc_cmd(CCV_NNC_RMSNORM_CMUL_FORWARD, 0, self->params, 0);
3389 ccv_nnc_tensor_param_t output_params;
3390 if (self->params.rmsnorm_cmul.elementwise_affine)
3391 ccv_nnc_hint_tensor_auto(rmsnorm_cmul, (ccv_nnc_tensor_param_t []){
3392 params,
3393 rotation_params,
3394 scale_params,
3395 }, 3, ccv_nnc_no_hint, &output_params, 1);
3396 else
3397 ccv_nnc_hint_tensor_auto(rmsnorm_cmul, (ccv_nnc_tensor_param_t []){
3398 params,
3399 rotation_params,
3400 }, 2, ccv_nnc_no_hint, &output_params, 1);
3401 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3402 if (self->params.rmsnorm_cmul.elementwise_affine)
3403 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");
3404 else
3405 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_cmul, inputs, input_size, outputs, output_size, "rmsnorm_cmul");
3406}
3407
3408static 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)
3409{
3410 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3411 if (self->scale.graph)
3412 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);
3413}
3414
3415static 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)
3416{
3417 ccv_cnnp_model_rmsnorm_cmul_t* const self = (ccv_cnnp_model_rmsnorm_cmul_t*)super;
3418 if (self->scale.graph)
3419 add_to_array(parameters, self->scale, is_trainable);
3420}
3421
3422static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_cmul_copy(const ccv_cnnp_model_t* const super, void* const context);
3423
3424static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_cmul_isa = {
3425 .build = _ccv_cnnp_rmsnorm_cmul_build,
3426 .init_states = _ccv_cnnp_rmsnorm_cmul_init_states,
3427 .add_to_parameter = _ccv_cnnp_rmsnorm_cmul_add_to_parameter,
3428 .copy = _ccv_cnnp_rmsnorm_cmul_copy,
3429};
3430
3431ccv_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)
3432{
3433 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));
3434 model_rmsnorm_cmul->super.isa = &ccv_cnnp_rmsnorm_cmul_isa;
3435 model_rmsnorm_cmul->super.input_size = 2;
3436 model_rmsnorm_cmul->super.outputs = &model_rmsnorm_cmul->output;
3437 model_rmsnorm_cmul->super.output_size = 1;
3438 model_rmsnorm_cmul->super.is_trainable = is_trainable;
3439 ccv_cnnp_model_copy_name(&model_rmsnorm_cmul->super, name);
3440 model_rmsnorm_cmul->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3441 model_rmsnorm_cmul->scale.graph = 0;
3442 model_rmsnorm_cmul->params.rmsnorm_cmul.epsilon = epsilon;
3443 model_rmsnorm_cmul->params.rmsnorm_cmul.count = axis_count;
3444 model_rmsnorm_cmul->params.rmsnorm_cmul.elementwise_affine = elementwise_affine;
3445 memcpy(model_rmsnorm_cmul->params.rmsnorm_cmul.axis, axis, sizeof(int) * axis_count);
3446 return (ccv_cnnp_model_t*)model_rmsnorm_cmul;
3447}
3448
3449static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_cmul_copy(const ccv_cnnp_model_t* const super, void* const context)
3450{
3451 const ccv_cnnp_model_rmsnorm_cmul_t* const self = (const ccv_cnnp_model_rmsnorm_cmul_t*)super;
3452 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);
3453}
3454
3455// MARK - RMSNorm Gated Layer
3456
3457typedef struct {
3458 ccv_cnnp_model_t super;
3459 ccv_nnc_tensor_symbol_t output;
3460 ccv_nnc_tensor_symbol_t scale;
3461 ccv_nnc_cmd_param_t params;
3462} ccv_cnnp_model_rmsnorm_gated_t;
3463
3464static 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)
3465{
3466 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);
3467 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"
, 3467, __extension__ __PRETTY_FUNCTION__); }));
3468 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", 3468, __extension__ __PRETTY_FUNCTION__
); }));
3469 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3470 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3471 const ccv_nnc_tensor_param_t gate_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3472 ccv_nnc_tensor_param_t scale_params = params;
3473 const int nd = ccv_nnc_tensor_nd(params.dim);
3474 int i;
3475 for (i = 0; i < nd; i++)
3476 scale_params.dim[i] = 1;
3477 for (i = 0; i < self->params.rmsnorm_gated.count; i++)
3478 scale_params.dim[self->params.rmsnorm_gated.axis[i]] = params.dim[self->params.rmsnorm_gated.axis[i]];
3479 if (self->params.rmsnorm_gated.elementwise_affine)
3480 {
3481 if (!self->scale.graph)
3482 self->scale = ccv_nnc_tensor_symbol_new(graph, scale_params, "scale");
3483 }
3484 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
};
3485 const ccv_nnc_cmd_t rmsnorm_gated = ccv_nnc_cmd(CCV_NNC_RMSNORM_GATED_FORWARD, 0, self->params, 0);
3486 ccv_nnc_tensor_param_t output_params;
3487 if (self->params.rmsnorm_gated.elementwise_affine)
3488 ccv_nnc_hint_tensor_auto(rmsnorm_gated, (ccv_nnc_tensor_param_t []){
3489 params,
3490 gate_params,
3491 scale_params,
3492 }, 3, ccv_nnc_no_hint, &output_params, 1);
3493 else
3494 ccv_nnc_hint_tensor_auto(rmsnorm_gated, (ccv_nnc_tensor_param_t []){
3495 params,
3496 gate_params,
3497 }, 2, ccv_nnc_no_hint, &output_params, 1);
3498 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3499 if (self->params.rmsnorm_gated.elementwise_affine)
3500 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");
3501 else
3502 ccv_nnc_graph_exec_symbol_new(graph, rmsnorm_gated, inputs, input_size, outputs, output_size, "rmsnorm_gated");
3503}
3504
3505static 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)
3506{
3507 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3508 if (self->scale.graph)
3509 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);
3510}
3511
3512static 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)
3513{
3514 ccv_cnnp_model_rmsnorm_gated_t* const self = (ccv_cnnp_model_rmsnorm_gated_t*)super;
3515 if (self->scale.graph)
3516 add_to_array(parameters, self->scale, is_trainable);
3517}
3518
3519static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_gated_copy(const ccv_cnnp_model_t* const super, void* const context);
3520
3521static const ccv_cnnp_model_vtab_t ccv_cnnp_rmsnorm_gated_isa = {
3522 .build = _ccv_cnnp_rmsnorm_gated_build,
3523 .init_states = _ccv_cnnp_rmsnorm_gated_init_states,
3524 .add_to_parameter = _ccv_cnnp_rmsnorm_gated_add_to_parameter,
3525 .copy = _ccv_cnnp_rmsnorm_gated_copy,
3526};
3527
3528ccv_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 sigmoid_gate, const int is_trainable, const char* const name)
3529{
3530 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));
3531 model_rmsnorm_gated->super.isa = &ccv_cnnp_rmsnorm_gated_isa;
3532 model_rmsnorm_gated->super.input_size = 2;
3533 model_rmsnorm_gated->super.outputs = &model_rmsnorm_gated->output;
3534 model_rmsnorm_gated->super.output_size = 1;
3535 model_rmsnorm_gated->super.is_trainable = is_trainable;
3536 ccv_cnnp_model_copy_name(&model_rmsnorm_gated->super, name);
3537 model_rmsnorm_gated->scale.d = CCV_NNC_NO_TENSOR_SYMBOL;
3538 model_rmsnorm_gated->scale.graph = 0;
3539 model_rmsnorm_gated->params.rmsnorm_gated.epsilon = epsilon;
3540 model_rmsnorm_gated->params.rmsnorm_gated.count = axis_count;
3541 model_rmsnorm_gated->params.rmsnorm_gated.elementwise_affine = elementwise_affine;
3542 model_rmsnorm_gated->params.rmsnorm_gated.sigmoid_gate = sigmoid_gate;
3543 memcpy(model_rmsnorm_gated->params.rmsnorm_gated.axis, axis, sizeof(int) * axis_count);
3544 return (ccv_cnnp_model_t*)model_rmsnorm_gated;
3545}
3546
3547static ccv_cnnp_model_t* _ccv_cnnp_rmsnorm_gated_copy(const ccv_cnnp_model_t* const super, void* const context)
3548{
3549 const ccv_cnnp_model_rmsnorm_gated_t* const self = (const ccv_cnnp_model_rmsnorm_gated_t*)super;
3550 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->params.rmsnorm_gated.sigmoid_gate, self->super.is_trainable, self->super.name);
3551}
3552
3553// MARK - Batched Matrix Mul Layer
3554
3555typedef struct {
3556 ccv_cnnp_model_t super;
3557 ccv_nnc_tensor_symbol_t output;
3558 int transpose_a[2];
3559 int transpose_b[2];
3560 int flags;
3561} ccv_cnnp_model_matmul_t;
3562
3563static 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)
3564{
3565 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);
3566 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"
, 3566, __extension__ __PRETTY_FUNCTION__); }));
3567 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", 3567, __extension__ __PRETTY_FUNCTION__
); }));
3568 ccv_cnnp_model_matmul_t* const self = (ccv_cnnp_model_matmul_t*)super;
3569 ccv_nnc_tensor_param_t a_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3570 ccv_nnc_tensor_param_t b_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3571 ccv_nnc_tensor_param_t output_params;
3572 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);
3573 matmul.info.blas.flags = self->flags;
3574 ccv_nnc_hint_tensor_auto(matmul, (ccv_nnc_tensor_param_t []){
3575 a_params,
3576 b_params,
3577 }, 2, ccv_nnc_no_hint, &output_params, 1);
3578 const ccv_nnc_tensor_symbol_t matmul_output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3579 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");
3580 outputs[0] = matmul_output;
3581}
3582
3583static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context);
3584
3585static const ccv_cnnp_model_vtab_t ccv_cnnp_matmul_isa = {
3586 .build = _ccv_cnnp_matmul_build,
3587 .copy = _ccv_cnnp_matmul_copy,
3588};
3589
3590ccv_cnnp_model_t* ccv_cnnp_matmul(const int transpose_a[2], const int transpose_b[2], const int flags, const char* const name)
3591{
3592 ccv_cnnp_model_matmul_t* const model_matmul = (ccv_cnnp_model_matmul_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_matmul_t));
3593 model_matmul->super.isa = &ccv_cnnp_matmul_isa;
3594 model_matmul->super.input_size = 2;
3595 model_matmul->super.outputs = &model_matmul->output;
3596 model_matmul->super.output_size = 1;
3597 model_matmul->transpose_a[0] = transpose_a[0];
3598 model_matmul->transpose_a[1] = transpose_a[1];
3599 model_matmul->transpose_b[0] = transpose_b[0];
3600 model_matmul->transpose_b[1] = transpose_b[1];
3601 model_matmul->flags = flags;
3602 ccv_cnnp_model_copy_name(&model_matmul->super, name);
3603 return (ccv_cnnp_model_t*)model_matmul;
3604}
3605
3606static ccv_cnnp_model_t* _ccv_cnnp_matmul_copy(const ccv_cnnp_model_t* const super, void* const context)
3607{
3608 const ccv_cnnp_model_matmul_t* const self = (const ccv_cnnp_model_matmul_t*)super;
3609 return ccv_cnnp_matmul(self->transpose_a, self->transpose_b, self->flags, self->super.name);
3610}
3611
3612// MARK - Dropout Layer
3613
3614typedef struct {
3615 ccv_cnnp_model_t super;
3616 ccv_nnc_tensor_symbol_t output;
3617 ccv_nnc_graph_exec_symbol_t dropout;
3618 float p;
3619 int entirety;
3620} ccv_cnnp_model_dropout_t;
3621
3622static 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)
3623{
3624 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);
3625 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"
, 3625, __extension__ __PRETTY_FUNCTION__); }));
3626 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", 3626, __extension__ __PRETTY_FUNCTION__
); }));
3627 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3628 ccv_nnc_tensor_param_t output_params[2];
3629 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
3630 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);
3631 ccv_nnc_hint_tensor_auto(dropout, (ccv_nnc_tensor_param_t []){
3632 params,
3633 }, 1, ccv_nnc_no_hint, output_params, 2);
3634 const ccv_nnc_tensor_symbol_t dropout_output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
3635 const ccv_nnc_tensor_symbol_t mask = ccv_nnc_tensor_symbol_new(graph, output_params[1], "mask");
3636 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");
3637 outputs[0] = dropout_output;
3638}
3639
3640static 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)
3641{
3642 ccv_cnnp_model_dropout_t* const self = (ccv_cnnp_model_dropout_t*)super;
3643 if (self->dropout.graph)
3644 {
3645 if (is_test)
3646 // During test, the dropout is not applied. Data transfer is perfect because if these are the same tensor, it will skip.
3647 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);
3648 else
3649 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);
3650 }
3651}
3652
3653static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context);
3654
3655static const ccv_cnnp_model_vtab_t ccv_cnnp_dropout_isa = {
3656 .build = _ccv_cnnp_dropout_build,
3657 .set_is_test = _ccv_cnnp_dropout_set_is_test,
3658 .copy = _ccv_cnnp_dropout_copy,
3659};
3660
3661ccv_cnnp_model_t* ccv_cnnp_dropout(const float p, const int entirety, const char* const name)
3662{
3663 ccv_cnnp_model_dropout_t* const model_dropout = (ccv_cnnp_model_dropout_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_dropout_t));
3664 model_dropout->super.isa = &ccv_cnnp_dropout_isa;
3665 model_dropout->super.input_size = 1;
3666 model_dropout->super.outputs = &model_dropout->output;
3667 model_dropout->super.output_size = 1;
3668 model_dropout->p = p;
3669 model_dropout->entirety = entirety;
3670 ccv_cnnp_model_copy_name(&model_dropout->super, name);
3671 return (ccv_cnnp_model_t*)model_dropout;
3672}
3673
3674static ccv_cnnp_model_t* _ccv_cnnp_dropout_copy(const ccv_cnnp_model_t* const super, void* const context)
3675{
3676 const ccv_cnnp_model_dropout_t* const self = (const ccv_cnnp_model_dropout_t*)super;
3677 return ccv_cnnp_dropout(self->p, self->entirety, self->super.name);
3678}
3679
3680// MARK - Masked Fill Layer
3681
3682typedef struct {
3683 ccv_cnnp_model_t super;
3684 ccv_nnc_tensor_symbol_t output;
3685 float eq;
3686 float fill;
3687} ccv_cnnp_model_masked_fill_t;
3688
3689static 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)
3690{
3691 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);
3692 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"
, 3692, __extension__ __PRETTY_FUNCTION__); }));
3693 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", 3693, __extension__ __PRETTY_FUNCTION__
); }));
3694 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3695 ccv_cnnp_model_masked_fill_t* const self = (ccv_cnnp_model_masked_fill_t*)super;
3696 const ccv_nnc_tensor_symbol_t masked_fill_output = ccv_nnc_tensor_symbol_new(graph, params, 0);
3697 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");
3698 outputs[0] = masked_fill_output;
3699}
3700
3701static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context);
3702
3703static const ccv_cnnp_model_vtab_t ccv_cnnp_masked_fill_isa = {
3704 .build = _ccv_cnnp_masked_fill_build,
3705 .copy = _ccv_cnnp_masked_fill_copy,
3706};
3707
3708ccv_cnnp_model_t* ccv_cnnp_masked_fill(const float eq, const float fill, const char* const name)
3709{
3710 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));
3711 model_masked_fill->super.isa = &ccv_cnnp_masked_fill_isa;
3712 model_masked_fill->super.input_size = 2;
3713 model_masked_fill->super.outputs = &model_masked_fill->output;
3714 model_masked_fill->super.output_size = 1;
3715 model_masked_fill->eq = eq;
3716 model_masked_fill->fill = fill;
3717 ccv_cnnp_model_copy_name(&model_masked_fill->super, name);
3718 return (ccv_cnnp_model_t*)model_masked_fill;
3719}
3720
3721static ccv_cnnp_model_t* _ccv_cnnp_masked_fill_copy(const ccv_cnnp_model_t* const super, void* const context)
3722{
3723 const ccv_cnnp_model_masked_fill_t* const self = (const ccv_cnnp_model_masked_fill_t*)super;
3724 return ccv_cnnp_masked_fill(self->eq, self->fill, self->super.name);
3725}
3726
3727// MARK - Index Select Layer
3728
3729typedef struct {
3730 ccv_cnnp_model_t super;
3731 ccv_nnc_tensor_symbol_t output;
3732} ccv_cnnp_model_index_select_t;
3733
3734static 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)
3735{
3736 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);
3737 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"
, 3737, __extension__ __PRETTY_FUNCTION__); }));
3738 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", 3738, __extension__ __PRETTY_FUNCTION__
); }));
3739 const ccv_nnc_tensor_param_t vocab_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3740 const ccv_nnc_tensor_param_t index_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
3741 ccv_nnc_tensor_param_t output_params;
3742 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);
3743 ccv_nnc_hint_tensor_auto(index_select, (ccv_nnc_tensor_param_t []){
3744 vocab_params,
3745 index_params,
3746 }, 2, ccv_nnc_no_hint, &output_params, 1);
3747 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3748 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");
3749 outputs[0] = output;
3750}
3751
3752static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context);
3753
3754static const ccv_cnnp_model_vtab_t ccv_cnnp_index_select_isa = {
3755 .build = _ccv_cnnp_index_select_build,
3756 .copy = _ccv_cnnp_index_select_copy,
3757};
3758
3759ccv_cnnp_model_t* ccv_cnnp_index_select(const char* const name)
3760{
3761 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));
3762 model_index_select->super.isa = &ccv_cnnp_index_select_isa;
3763 model_index_select->super.input_size = 2;
3764 model_index_select->super.outputs = &model_index_select->output;
3765 model_index_select->super.output_size = 1;
3766 ccv_cnnp_model_copy_name(&model_index_select->super, name);
3767 return (ccv_cnnp_model_t*)model_index_select;
3768}
3769
3770static ccv_cnnp_model_t* _ccv_cnnp_index_select_copy(const ccv_cnnp_model_t* const super, void* const context)
3771{
3772 ccv_cnnp_model_index_select_t* const self = (ccv_cnnp_model_index_select_t*)super;
3773 return ccv_cnnp_index_select(self->super.name);
3774}
3775
3776// MARK - Embedding Layer
3777
3778typedef struct {
3779 ccv_cnnp_model_t super;
3780 ccv_nnc_tensor_symbol_t output;
3781 ccv_nnc_tensor_symbol_t vocab;
3782 int datatype;
3783 int vocab_size;
3784 int embed_size;
3785} ccv_cnnp_model_embedding_t;
3786
3787static 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)
3788{
3789 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3790 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);
3791 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"
, 3791, __extension__ __PRETTY_FUNCTION__); }));
3792 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", 3792, __extension__ __PRETTY_FUNCTION__
); }));
3793 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3794 ccv_nnc_tensor_param_t vocab_params = params;
3795 memset(vocab_params.dim, 0, sizeof(vocab_params.dim));
3796 vocab_params.datatype = self->datatype;
3797 vocab_params.dim[0] = self->vocab_size;
3798 vocab_params.dim[1] = self->embed_size;
3799 if (!self->vocab.graph)
3800 self->vocab = ccv_nnc_tensor_symbol_new(graph, vocab_params, "vocab");
3801 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", 3801
, __extension__ __PRETTY_FUNCTION__); }));
3802 const ccv_nnc_tensor_symbol_t vocab = ccv_cnnp_model_get_symbol(super, self->vocab);
3803 ccv_nnc_tensor_param_t output_params;
3804 const ccv_nnc_cmd_t embedding = CMD_INDEX_SELECT_FORWARD()ccv_nnc_cmd(CCV_NNC_INDEX_SELECT_FORWARD, 0, ccv_nnc_cmd_auto
, 0);
3805 ccv_nnc_hint_tensor_auto(embedding, (ccv_nnc_tensor_param_t []){
3806 vocab_params,
3807 params,
3808 }, 2, ccv_nnc_no_hint, &output_params, 1);
3809 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3810 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");
3811 outputs[0] = output;
3812}
3813
3814static 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)
3815{
3816 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3817 const float std = sqrtf(2) / sqrtf(self->vocab_size + self->embed_size);
3818 const float bound = sqrtf(3) * std;
3819 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);
3820}
3821
3822static 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)
3823{
3824 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3825 add_to_array(parameters, self->vocab, is_trainable);
3826}
3827
3828static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context);
3829
3830static const ccv_cnnp_model_vtab_t ccv_cnnp_embedding_isa = {
3831 .build = _ccv_cnnp_embedding_build,
3832 .init_states = _ccv_cnnp_embedding_init_states,
3833 .add_to_parameter = _ccv_cnnp_embedding_add_to_parameter,
3834 .copy = _ccv_cnnp_embedding_copy,
3835};
3836
3837ccv_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)
3838{
3839 ccv_cnnp_model_embedding_t* const model_embedding = (ccv_cnnp_model_embedding_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_embedding_t));
3840 model_embedding->super.isa = &ccv_cnnp_embedding_isa;
3841 model_embedding->super.input_size = 1;
3842 model_embedding->super.outputs = &model_embedding->output;
3843 model_embedding->super.output_size = 1;
3844 model_embedding->super.is_trainable = is_trainable;
3845 ccv_cnnp_model_copy_name(&model_embedding->super, name);
3846 model_embedding->vocab.d = CCV_NNC_NO_TENSOR_SYMBOL;
3847 model_embedding->vocab.graph = 0;
3848 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", 3848, __extension__ __PRETTY_FUNCTION__
); }));
3849 model_embedding->datatype = datatype;
3850 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", 3850, __extension__ __PRETTY_FUNCTION__
); }));
3851 model_embedding->vocab_size = vocab_size;
3852 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", 3852, __extension__ __PRETTY_FUNCTION__
); }));
3853 model_embedding->embed_size = embed_size;
3854 return (ccv_cnnp_model_t*)model_embedding;
3855}
3856
3857static ccv_cnnp_model_t* _ccv_cnnp_embedding_copy(const ccv_cnnp_model_t* const super, void* const context)
3858{
3859 ccv_cnnp_model_embedding_t* const self = (ccv_cnnp_model_embedding_t*)super;
3860 return ccv_cnnp_embedding(self->datatype, self->vocab_size, self->embed_size, self->super.is_trainable, self->super.name);
3861}
3862
3863// MARK - Pool Layers
3864
3865typedef struct {
3866 ccv_cnnp_model_t super;
3867 ccv_nnc_tensor_symbol_t output;
3868 int type;
3869 float width_scale;
3870 float height_scale;
3871 int align_corners;
3872} ccv_cnnp_model_upsample_t;
3873
3874static 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)
3875{
3876 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);
3877 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"
, 3877, __extension__ __PRETTY_FUNCTION__); }));
3878 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", 3878, __extension__ __PRETTY_FUNCTION__
); }));
3879 ccv_cnnp_model_upsample_t* const self = (ccv_cnnp_model_upsample_t*)super;
3880 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3881 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);
3882 ccv_nnc_tensor_param_t output_params;
3883 ccv_nnc_hint_tensor_auto(cmd, &params, 1, ccv_nnc_no_hint, &output_params, 1);
3884 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3885 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");
3886 outputs[0] = output;
3887}
3888
3889static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context);
3890
3891static const ccv_cnnp_model_vtab_t ccv_cnnp_upsample_isa = {
3892 .build = _ccv_cnnp_upsample_build,
3893 .copy = _ccv_cnnp_upsample_copy,
3894};
3895
3896ccv_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)
3897{
3898 ccv_cnnp_model_upsample_t* const model_upsample = (ccv_cnnp_model_upsample_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_upsample_t));
3899 model_upsample->super.isa = &ccv_cnnp_upsample_isa;
3900 model_upsample->super.input_size = 1;
3901 model_upsample->super.outputs = &model_upsample->output;
3902 model_upsample->super.output_size = 1;
3903 ccv_cnnp_model_copy_name(&model_upsample->super, name);
3904 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", 3904, __extension__ __PRETTY_FUNCTION__
); }));
3905 model_upsample->type = type;
3906 model_upsample->width_scale = width_scale;
3907 model_upsample->height_scale = height_scale;
3908 model_upsample->align_corners = align_corners;
3909 return (ccv_cnnp_model_t*)model_upsample;
3910}
3911
3912static ccv_cnnp_model_t* _ccv_cnnp_upsample_copy(const ccv_cnnp_model_t* const super, void* const context)
3913{
3914 const ccv_cnnp_model_upsample_t* const self = (const ccv_cnnp_model_upsample_t*)super;
3915 return ccv_cnnp_upsample(self->type, self->width_scale, self->height_scale, self->align_corners, self->super.name);
3916}
3917
3918// MARK - Reduce Sum Layer
3919
3920typedef struct {
3921 ccv_cnnp_model_t super;
3922 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3923 int count;
3924 ccv_nnc_tensor_symbol_t output;
3925} ccv_cnnp_model_reduce_sum_t;
3926
3927static 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)
3928{
3929 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);
3930 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
3931 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"
, 3931, __extension__ __PRETTY_FUNCTION__); }));
3932 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", 3932, __extension__ __PRETTY_FUNCTION__
); }));
3933 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3934 ccv_nnc_tensor_param_t output_params;
3935 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);
3936 int i;
3937 for (i = 0; i < self->count; i++)
3938 reduce_sum.info.reduce.axis[i] = self->axis[i];
3939 reduce_sum.info.reduce.count = self->count;
3940 ccv_nnc_hint_tensor_auto(reduce_sum, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3941 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3942 ccv_nnc_graph_exec_symbol_new(graph, reduce_sum, inputs, input_size, outputs, output_size, "reduce_sum");
3943}
3944
3945static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const self, void* const context);
3946
3947static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_sum_isa = {
3948 .build = _ccv_cnnp_reduce_sum_build,
3949 .copy = _ccv_cnnp_reduce_sum_copy,
3950};
3951
3952ccv_cnnp_model_t* ccv_cnnp_reduce_sum(const int* const axis, const int axis_count, const char* const name)
3953{
3954 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));
3955 model_reduce_sum->super.isa = &ccv_cnnp_reduce_sum_isa;
3956 model_reduce_sum->super.input_size = 1;
3957 model_reduce_sum->super.outputs = &model_reduce_sum->output;
3958 model_reduce_sum->super.output_size = 1;
3959 ccv_cnnp_model_copy_name(&model_reduce_sum->super, name);
3960 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", 3960, __extension__ __PRETTY_FUNCTION__
); }));
3961 int i;
3962 for (i = 0; i < axis_count; i++)
3963 model_reduce_sum->axis[i] = axis[i];
3964 model_reduce_sum->count = axis_count;
3965 return (ccv_cnnp_model_t*)model_reduce_sum;
3966}
3967
3968static ccv_cnnp_model_t* _ccv_cnnp_reduce_sum_copy(const ccv_cnnp_model_t* const super, void* const context)
3969{
3970 const ccv_cnnp_model_reduce_sum_t* const self = (const ccv_cnnp_model_reduce_sum_t*)super;
3971 return ccv_cnnp_reduce_sum(self->axis, self->count, self->super.name);
3972}
3973
3974// MARK - Reduce Mean Layer
3975
3976typedef struct {
3977 ccv_cnnp_model_t super;
3978 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
3979 int count;
3980 ccv_nnc_tensor_symbol_t output;
3981} ccv_cnnp_model_reduce_mean_t;
3982
3983static 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)
3984{
3985 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);
3986 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
3987 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"
, 3987, __extension__ __PRETTY_FUNCTION__); }));
3988 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", 3988, __extension__ __PRETTY_FUNCTION__
); }));
3989 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
3990 ccv_nnc_tensor_param_t output_params;
3991 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);
3992 int i;
3993 for (i = 0; i < self->count; i++)
3994 reduce_mean.info.reduce.axis[i] = self->axis[i];
3995 reduce_mean.info.reduce.count = self->count;
3996 ccv_nnc_hint_tensor_auto(reduce_mean, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
3997 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
3998 ccv_nnc_graph_exec_symbol_new(graph, reduce_mean, inputs, input_size, outputs, output_size, "reduce_mean");
3999}
4000
4001static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const self, void* const context);
4002
4003static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_mean_isa = {
4004 .build = _ccv_cnnp_reduce_mean_build,
4005 .copy = _ccv_cnnp_reduce_mean_copy,
4006};
4007
4008ccv_cnnp_model_t* ccv_cnnp_reduce_mean(const int* const axis, const int axis_count, const char* const name)
4009{
4010 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));
4011 model_reduce_mean->super.isa = &ccv_cnnp_reduce_mean_isa;
4012 model_reduce_mean->super.input_size = 1;
4013 model_reduce_mean->super.outputs = &model_reduce_mean->output;
4014 model_reduce_mean->super.output_size = 1;
4015 ccv_cnnp_model_copy_name(&model_reduce_mean->super, name);
4016 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", 4016, __extension__ __PRETTY_FUNCTION__
); }));
4017 int i;
4018 for (i = 0; i < axis_count; i++)
4019 model_reduce_mean->axis[i] = axis[i];
4020 model_reduce_mean->count = axis_count;
4021 return (ccv_cnnp_model_t*)model_reduce_mean;
4022}
4023
4024static ccv_cnnp_model_t* _ccv_cnnp_reduce_mean_copy(const ccv_cnnp_model_t* const super, void* const context)
4025{
4026 const ccv_cnnp_model_reduce_mean_t* const self = (const ccv_cnnp_model_reduce_mean_t*)super;
4027 return ccv_cnnp_reduce_mean(self->axis, self->count, self->super.name);
4028}
4029
4030// MARK - Reduce Max Layer
4031
4032typedef struct {
4033 ccv_cnnp_model_t super;
4034 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
4035 int count;
4036 ccv_nnc_tensor_symbol_t output;
4037} ccv_cnnp_model_reduce_max_t;
4038
4039static 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)
4040{
4041 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);
4042 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
4043 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"
, 4043, __extension__ __PRETTY_FUNCTION__); }));
4044 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", 4044, __extension__ __PRETTY_FUNCTION__
); }));
4045 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4046 ccv_nnc_tensor_param_t output_params;
4047 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);
4048 int i;
4049 for (i = 0; i < self->count; i++)
4050 reduce_max.info.reduce.axis[i] = self->axis[i];
4051 reduce_max.info.reduce.count = self->count;
4052 ccv_nnc_hint_tensor_auto(reduce_max, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4053 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4054 ccv_nnc_graph_exec_symbol_new(graph, reduce_max, inputs, input_size, outputs, output_size, "reduce_max");
4055}
4056
4057static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const self, void* const context);
4058
4059static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_max_isa = {
4060 .build = _ccv_cnnp_reduce_max_build,
4061 .copy = _ccv_cnnp_reduce_max_copy,
4062};
4063
4064ccv_cnnp_model_t* ccv_cnnp_reduce_max(const int* const axis, const int axis_count, const char* const name)
4065{
4066 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));
4067 model_reduce_max->super.isa = &ccv_cnnp_reduce_max_isa;
4068 model_reduce_max->super.input_size = 1;
4069 model_reduce_max->super.outputs = &model_reduce_max->output;
4070 model_reduce_max->super.output_size = 1;
4071 ccv_cnnp_model_copy_name(&model_reduce_max->super, name);
4072 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", 4072, __extension__ __PRETTY_FUNCTION__
); }));
4073 int i;
4074 for (i = 0; i < axis_count; i++)
4075 model_reduce_max->axis[i] = axis[i];
4076 model_reduce_max->count = axis_count;
4077 return (ccv_cnnp_model_t*)model_reduce_max;
4078}
4079
4080static ccv_cnnp_model_t* _ccv_cnnp_reduce_max_copy(const ccv_cnnp_model_t* const super, void* const context)
4081{
4082 const ccv_cnnp_model_reduce_max_t* const self = (const ccv_cnnp_model_reduce_max_t*)super;
4083 return ccv_cnnp_reduce_max(self->axis, self->count, self->super.name);
4084}
4085
4086// MARK - Reduce Min Layer
4087
4088typedef struct {
4089 ccv_cnnp_model_t super;
4090 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
4091 int count;
4092 ccv_nnc_tensor_symbol_t output;
4093} ccv_cnnp_model_reduce_min_t;
4094
4095static 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)
4096{
4097 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);
4098 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
4099 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"
, 4099, __extension__ __PRETTY_FUNCTION__); }));
4100 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", 4100, __extension__ __PRETTY_FUNCTION__
); }));
4101 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4102 ccv_nnc_tensor_param_t output_params;
4103 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);
4104 int i;
4105 for (i = 0; i < self->count; i++)
4106 reduce_min.info.reduce.axis[i] = self->axis[i];
4107 reduce_min.info.reduce.count = self->count;
4108 ccv_nnc_hint_tensor_auto(reduce_min, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4109 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4110 ccv_nnc_graph_exec_symbol_new(graph, reduce_min, inputs, input_size, outputs, output_size, "reduce_min");
4111}
4112
4113static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const self, void* const context);
4114
4115static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_min_isa = {
4116 .build = _ccv_cnnp_reduce_min_build,
4117 .copy = _ccv_cnnp_reduce_min_copy,
4118};
4119
4120ccv_cnnp_model_t* ccv_cnnp_reduce_min(const int* const axis, const int axis_count, const char* const name)
4121{
4122 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));
4123 model_reduce_min->super.isa = &ccv_cnnp_reduce_min_isa;
4124 model_reduce_min->super.input_size = 1;
4125 model_reduce_min->super.outputs = &model_reduce_min->output;
4126 model_reduce_min->super.output_size = 1;
4127 ccv_cnnp_model_copy_name(&model_reduce_min->super, name);
4128 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", 4128, __extension__ __PRETTY_FUNCTION__
); }));
4129 int i;
4130 for (i = 0; i < axis_count; i++)
4131 model_reduce_min->axis[i] = axis[i];
4132 model_reduce_min->count = axis_count;
4133 return (ccv_cnnp_model_t*)model_reduce_min;
4134}
4135
4136static ccv_cnnp_model_t* _ccv_cnnp_reduce_min_copy(const ccv_cnnp_model_t* const super, void* const context)
4137{
4138 const ccv_cnnp_model_reduce_min_t* const self = (const ccv_cnnp_model_reduce_min_t*)super;
4139 return ccv_cnnp_reduce_min(self->axis, self->count, self->super.name);
4140}
4141
4142// MARK - Reduce Norm2 Layer
4143
4144typedef struct {
4145 ccv_cnnp_model_t super;
4146 int axis[CCV_NNC_MAX_DIM_ALLOC(12)];
4147 int count;
4148 ccv_nnc_tensor_symbol_t output;
4149} ccv_cnnp_model_reduce_norm2_t;
4150
4151static 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)
4152{
4153 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
4154 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);
4155 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"
, 4155, __extension__ __PRETTY_FUNCTION__); }));
4156 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", 4156, __extension__ __PRETTY_FUNCTION__
); }));
4157 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4158 ccv_nnc_tensor_param_t output_params;
4159 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);
4160 int i;
4161 for (i = 0; i < self->count; i++)
4162 reduce_norm2.info.reduce.axis[i] = self->axis[i];
4163 reduce_norm2.info.reduce.count = self->count;
4164 ccv_nnc_hint_tensor_auto(reduce_norm2, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4165 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4166 ccv_nnc_graph_exec_symbol_new(graph, reduce_norm2, inputs, input_size, outputs, output_size, "reduce_norm2");
4167}
4168
4169static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const self, void* const context);
4170
4171static const ccv_cnnp_model_vtab_t ccv_cnnp_reduce_norm2_isa = {
4172 .build = _ccv_cnnp_reduce_norm2_build,
4173 .copy = _ccv_cnnp_reduce_norm2_copy,
4174};
4175
4176ccv_cnnp_model_t* ccv_cnnp_reduce_norm2(const int* const axis, const int axis_count, const char* const name)
4177{
4178 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));
4179 model_reduce_norm2->super.isa = &ccv_cnnp_reduce_norm2_isa;
4180 model_reduce_norm2->super.input_size = 1;
4181 model_reduce_norm2->super.outputs = &model_reduce_norm2->output;
4182 model_reduce_norm2->super.output_size = 1;
4183 ccv_cnnp_model_copy_name(&model_reduce_norm2->super, name);
4184 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", 4184, __extension__ __PRETTY_FUNCTION__
); }));
4185 int i;
4186 for (i = 0; i < axis_count; i++)
4187 model_reduce_norm2->axis[i] = axis[i];
4188 model_reduce_norm2->count = axis_count;
4189 return (ccv_cnnp_model_t*)model_reduce_norm2;
4190}
4191
4192static ccv_cnnp_model_t* _ccv_cnnp_reduce_norm2_copy(const ccv_cnnp_model_t* const super, void* const context)
4193{
4194 const ccv_cnnp_model_reduce_norm2_t* const self = (const ccv_cnnp_model_reduce_norm2_t*)super;
4195 return ccv_cnnp_reduce_norm2(self->axis, self->count, self->super.name);
4196}
4197
4198// MARK - Argmax Layer
4199
4200typedef struct {
4201 ccv_cnnp_model_t super;
4202 int axis;
4203 ccv_nnc_tensor_symbol_t output;
4204} ccv_cnnp_model_argmax_t;
4205
4206static 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)
4207{
4208 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
4209 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);
4210 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"
, 4210, __extension__ __PRETTY_FUNCTION__); }));
4211 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", 4211, __extension__ __PRETTY_FUNCTION__
); }));
4212 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4213 ccv_nnc_tensor_param_t output_params;
4214 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);
4215 argmax.info.reduce.axis[0] = self->axis;
4216 argmax.info.reduce.count = 1;
4217 ccv_nnc_hint_tensor_auto(argmax, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4218 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4219 ccv_nnc_graph_exec_symbol_new(graph, argmax, inputs, input_size, outputs, output_size, "argmax");
4220}
4221
4222static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const self, void* const context);
4223
4224static const ccv_cnnp_model_vtab_t ccv_cnnp_argmax_isa = {
4225 .build = _ccv_cnnp_argmax_build,
4226 .copy = _ccv_cnnp_argmax_copy,
4227};
4228
4229ccv_cnnp_model_t* ccv_cnnp_argmax(const int axis, const char* const name)
4230{
4231 ccv_cnnp_model_argmax_t* const model_argmax = (ccv_cnnp_model_argmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmax_t));
4232 model_argmax->super.isa = &ccv_cnnp_argmax_isa;
4233 model_argmax->super.input_size = 1;
4234 model_argmax->super.outputs = &model_argmax->output;
4235 model_argmax->super.output_size = 1;
4236 ccv_cnnp_model_copy_name(&model_argmax->super, name);
4237 model_argmax->axis = axis;
4238 return (ccv_cnnp_model_t*)model_argmax;
4239}
4240
4241static ccv_cnnp_model_t* _ccv_cnnp_argmax_copy(const ccv_cnnp_model_t* const super, void* const context)
4242{
4243 const ccv_cnnp_model_argmax_t* const self = (const ccv_cnnp_model_argmax_t*)super;
4244 return ccv_cnnp_argmax(self->axis, self->super.name);
4245}
4246
4247// MARK - Gumbel Argmax Layer
4248
4249typedef struct {
4250 ccv_cnnp_model_t super;
4251 int axis;
4252 float scale;
4253 ccv_nnc_tensor_symbol_t output;
4254} ccv_cnnp_model_gumbel_argmax_t;
4255
4256static void _ccv_cnnp_gumbel_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)
4257{
4258 const ccv_cnnp_model_gumbel_argmax_t* const self = (const ccv_cnnp_model_gumbel_argmax_t*)super;
4259 PRINT(CCV_CLI_VERBOSE, "[cnnp_gumbel_argmax_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_gumbel_argmax_build] -\n"); fflush(stdout); }
} while (0);
4260 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"
, 4260, __extension__ __PRETTY_FUNCTION__); }));
4261 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", 4261, __extension__ __PRETTY_FUNCTION__
); }));
4262 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4263 ccv_nnc_tensor_param_t output_params;
4264 ccv_nnc_cmd_t gumbel_argmax = CMD_GUMBEL_ARGMAX_FORWARD(self->scale, self->axis)ccv_nnc_cmd(CCV_NNC_GUMBEL_ARGMAX_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.reduce={.count=(1 +1 +0 +0 +0 +0 +0 +
0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0
+0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +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={self
->axis},.scale=(self->scale)}}), 0);
4265 ccv_nnc_hint_tensor_auto(gumbel_argmax, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4266 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4267 ccv_nnc_graph_exec_symbol_new(graph, gumbel_argmax, inputs, input_size, outputs, output_size, "gumbel_argmax");
4268}
4269
4270static ccv_cnnp_model_t* _ccv_cnnp_gumbel_argmax_copy(const ccv_cnnp_model_t* const self, void* const context);
4271
4272static const ccv_cnnp_model_vtab_t ccv_cnnp_gumbel_argmax_isa = {
4273 .build = _ccv_cnnp_gumbel_argmax_build,
4274 .copy = _ccv_cnnp_gumbel_argmax_copy,
4275};
4276
4277ccv_cnnp_model_t* ccv_cnnp_gumbel_argmax(const int axis, const float scale, const char* const name)
4278{
4279 ccv_cnnp_model_gumbel_argmax_t* const model_gumbel_argmax = (ccv_cnnp_model_gumbel_argmax_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_gumbel_argmax_t));
4280 model_gumbel_argmax->super.isa = &ccv_cnnp_gumbel_argmax_isa;
4281 model_gumbel_argmax->super.input_size = 1;
4282 model_gumbel_argmax->super.outputs = &model_gumbel_argmax->output;
4283 model_gumbel_argmax->super.output_size = 1;
4284 ccv_cnnp_model_copy_name(&model_gumbel_argmax->super, name);
4285 model_gumbel_argmax->axis = axis;
4286 model_gumbel_argmax->scale = scale;
4287 return (ccv_cnnp_model_t*)model_gumbel_argmax;
4288}
4289
4290static ccv_cnnp_model_t* _ccv_cnnp_gumbel_argmax_copy(const ccv_cnnp_model_t* const super, void* const context)
4291{
4292 const ccv_cnnp_model_gumbel_argmax_t* const self = (const ccv_cnnp_model_gumbel_argmax_t*)super;
4293 return ccv_cnnp_gumbel_argmax(self->axis, self->scale, self->super.name);
4294}
4295
4296// MARK - Argmin Layer
4297
4298typedef struct {
4299 ccv_cnnp_model_t super;
4300 int axis;
4301 ccv_nnc_tensor_symbol_t output;
4302} ccv_cnnp_model_argmin_t;
4303
4304static 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)
4305{
4306 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
4307 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);
4308 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"
, 4308, __extension__ __PRETTY_FUNCTION__); }));
4309 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", 4309, __extension__ __PRETTY_FUNCTION__
); }));
4310 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4311 ccv_nnc_tensor_param_t output_params;
4312 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);
4313 argmin.info.reduce.axis[0] = self->axis;
4314 argmin.info.reduce.count = 1;
4315 ccv_nnc_hint_tensor_auto(argmin, &input_params, 1, ccv_nnc_no_hint, &output_params, 1);
4316 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4317 ccv_nnc_graph_exec_symbol_new(graph, argmin, inputs, input_size, outputs, output_size, "argmin");
4318}
4319
4320static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const self, void* const context);
4321
4322static const ccv_cnnp_model_vtab_t ccv_cnnp_argmin_isa = {
4323 .build = _ccv_cnnp_argmin_build,
4324 .copy = _ccv_cnnp_argmin_copy,
4325};
4326
4327ccv_cnnp_model_t* ccv_cnnp_argmin(const int axis, const char* const name)
4328{
4329 ccv_cnnp_model_argmin_t* const model_argmin = (ccv_cnnp_model_argmin_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_argmin_t));
4330 model_argmin->super.isa = &ccv_cnnp_argmin_isa;
4331 model_argmin->super.input_size = 1;
4332 model_argmin->super.outputs = &model_argmin->output;
4333 model_argmin->super.output_size = 1;
4334 ccv_cnnp_model_copy_name(&model_argmin->super, name);
4335 model_argmin->axis = axis;
4336 return (ccv_cnnp_model_t*)model_argmin;
4337}
4338
4339static ccv_cnnp_model_t* _ccv_cnnp_argmin_copy(const ccv_cnnp_model_t* const super, void* const context)
4340{
4341 const ccv_cnnp_model_argmin_t* const self = (const ccv_cnnp_model_argmin_t*)super;
4342 return ccv_cnnp_argmin(self->axis, self->super.name);
4343}
4344
4345// MARK - Min Layer
4346
4347typedef struct {
4348 ccv_cnnp_model_t super;
4349 ccv_nnc_tensor_symbol_t output;
4350} ccv_cnnp_model_min_t;
4351
4352static 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)
4353{
4354 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);
4355 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"
, 4355, __extension__ __PRETTY_FUNCTION__); }));
4356 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", 4356, __extension__ __PRETTY_FUNCTION__
); }));
4357 ccv_nnc_tensor_param_t input_params[2];
4358 int i;
4359 for (i = 0; i < 2; i++)
4360 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
4361 ccv_nnc_tensor_param_t output_params;
4362 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);
4363 ccv_nnc_hint_tensor_auto(min, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
4364 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4365 ccv_nnc_graph_exec_symbol_new(graph, min, inputs, input_size, outputs, output_size, "min");
4366}
4367
4368static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const self, void* const context);
4369
4370static const ccv_cnnp_model_vtab_t ccv_cnnp_min_isa = {
4371 .build = _ccv_cnnp_min_build,
4372 .copy = _ccv_cnnp_min_copy,
4373};
4374
4375ccv_cnnp_model_t* ccv_cnnp_min(const char* const name)
4376{
4377 ccv_cnnp_model_min_t* const model_min = (ccv_cnnp_model_min_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_min_t));
4378 model_min->super.isa = &ccv_cnnp_min_isa;
4379 model_min->super.input_size = 2;
4380 model_min->super.outputs = &model_min->output;
4381 model_min->super.output_size = 1;
4382 ccv_cnnp_model_copy_name(&model_min->super, name);
4383 return (ccv_cnnp_model_t*)model_min;
4384}
4385
4386static ccv_cnnp_model_t* _ccv_cnnp_min_copy(const ccv_cnnp_model_t* const super, void* const context)
4387{
4388 const ccv_cnnp_model_min_t* const self = (const ccv_cnnp_model_min_t*)super;
4389 return ccv_cnnp_min(self->super.name);
4390}
4391
4392// MARK - Max Layer
4393
4394typedef struct {
4395 ccv_cnnp_model_t super;
4396 ccv_nnc_tensor_symbol_t output;
4397} ccv_cnnp_model_max_t;
4398
4399static 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)
4400{
4401 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);
4402 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"
, 4402, __extension__ __PRETTY_FUNCTION__); }));
4403 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", 4403, __extension__ __PRETTY_FUNCTION__
); }));
4404 ccv_nnc_tensor_param_t input_params[2];
4405 int i;
4406 for (i = 0; i < 2; i++)
4407 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
4408 ccv_nnc_tensor_param_t output_params;
4409 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);
4410 ccv_nnc_hint_tensor_auto(max, input_params, 2, ccv_nnc_no_hint, &output_params, 1);
4411 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
4412 ccv_nnc_graph_exec_symbol_new(graph, max, inputs, input_size, outputs, output_size, "max");
4413}
4414
4415static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const self, void* const context);
4416
4417static const ccv_cnnp_model_vtab_t ccv_cnnp_max_isa = {
4418 .build = _ccv_cnnp_max_build,
4419 .copy = _ccv_cnnp_max_copy,
4420};
4421
4422ccv_cnnp_model_t* ccv_cnnp_max(const char* const name)
4423{
4424 ccv_cnnp_model_max_t* const model_max = (ccv_cnnp_model_max_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_max_t));
4425 model_max->super.isa = &ccv_cnnp_max_isa;
4426 model_max->super.input_size = 2;
4427 model_max->super.outputs = &model_max->output;
4428 model_max->super.output_size = 1;
4429 ccv_cnnp_model_copy_name(&model_max->super, name);
4430 return (ccv_cnnp_model_t*)model_max;
4431}
4432
4433static ccv_cnnp_model_t* _ccv_cnnp_max_copy(const ccv_cnnp_model_t* const super, void* const context)
4434{
4435 const ccv_cnnp_model_max_t* const self = (const ccv_cnnp_model_max_t*)super;
4436 return ccv_cnnp_max(self->super.name);
4437}
4438
4439// MARK - LSTM Layer
4440
4441typedef struct {
4442 ccv_cnnp_model_t super;
4443 int masked;
4444 ccv_nnc_tensor_symbol_t output;
4445 ccv_nnc_tensor_symbol_t weights;
4446 ccv_nnc_tensor_symbol_t reserves;
4447 ccv_nnc_cmd_param_t params;
4448 ccv_nnc_graph_exec_symbol_t lstm;
4449} ccv_cnnp_model_lstm_t;
4450
4451static int _ccv_cnnp_lstm_weight_dim(int bidirectional, int num_layers, int input_size, int hidden_size, int proj_size, int bias)
4452{
4453 const int D = !!bidirectional + 1;
4454 if (hidden_size == proj_size)
4455 return (num_layers * (bias ? 8 : 0) + (num_layers - 1) * (hidden_size * 4 * D + hidden_size * 4) + input_size * 4 + hidden_size * 4) * D;
4456 else
4457 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;
4458}
4459
4460static 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)
4461{
4462 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4463 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);
4464 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", 4464, __extension__ __PRETTY_FUNCTION__
); }));
4465 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", 4465, __extension__ __PRETTY_FUNCTION__
); }));
4466 const int proj_size = self->params.rnn.proj_size == 0 ? self->params.rnn.hidden_size : self->params.rnn.proj_size;
4467 ccv_nnc_tensor_param_t input_params[5];
4468 input_params[0]= ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4469 if (input_size == 2)
4470 input_params[1] = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
4471 input_params[4] = input_params[0];
4472 memset(input_params[4].dim, 0, sizeof(input_params[4].dim));
4473 const int x_nd = ccv_nnc_tensor_nd(input_params[0].dim);
4474 const int feature_count = input_params[0].dim[x_nd - 1];
4475 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);
4476 input_params[4].dim[1] = self->params.rnn.hidden_size;
4477 const ccv_nnc_cmd_t lstm = ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0);
4478 ccv_nnc_tensor_param_t output_params[4];
4479 ccv_nnc_hint_tensor_auto(lstm, input_params, 5, ccv_nnc_no_hint, output_params, 4);
4480 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
4481 if (!self->weights.graph)
4482 self->weights = ccv_nnc_tensor_symbol_new(graph, input_params[4], "weights");
4483 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"
, 4483, __extension__ __PRETTY_FUNCTION__); }));
4484 const ccv_nnc_tensor_symbol_t weights = ccv_cnnp_model_get_symbol(super, self->weights);
4485 if (!self->reserves.graph)
4486 self->reserves = ccv_nnc_tensor_symbol_new(graph, output_params[3], "reserves");
4487 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"
, 4487, __extension__ __PRETTY_FUNCTION__); }));
4488 const ccv_nnc_tensor_symbol_t reserves = ccv_cnnp_model_get_symbol(super, self->reserves);
4489 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
};
4490 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");
4491}
4492
4493static 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)
4494{
4495 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4496 if (self->weights.graph)
4497 {
4498 const float stdv = 1.0 / sqrt(self->params.rnn.hidden_size);
4499 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);
4500 }
4501}
4502
4503static 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)
4504{
4505 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4506 if (self->weights.graph)
4507 add_to_array(parameters, self->weights, is_trainable);
4508}
4509
4510static 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)
4511{
4512 ccv_cnnp_model_lstm_t* const self = (ccv_cnnp_model_lstm_t*)super;
4513 if (self->lstm.graph)
4514 {
4515 self->params.rnn.is_test = is_test;
4516 updater(context, self->lstm, ccv_nnc_cmd(CCV_NNC_LSTM_FORWARD, 0, self->params, 0), ccv_nnc_no_hint);
4517 }
4518}
4519
4520static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const self, void* const context);
4521
4522static const ccv_cnnp_model_vtab_t ccv_cnnp_lstm_isa = {
4523 .build = _ccv_cnnp_lstm_build,
4524 .init_states = _ccv_cnnp_lstm_init_states,
4525 .add_to_parameter = _ccv_cnnp_lstm_add_to_parameter,
4526 .copy = _ccv_cnnp_lstm_copy,
4527 .set_is_test = _ccv_cnnp_lstm_set_is_test,
4528};
4529
4530ccv_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)
4531{
4532 ccv_cnnp_model_lstm_t* const model_lstm = (ccv_cnnp_model_lstm_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_lstm_t));
4533 model_lstm->super.isa = &ccv_cnnp_lstm_isa;
4534 model_lstm->super.input_size = masked ? 2 : 1;
4535 model_lstm->super.outputs = &model_lstm->output;
4536 model_lstm->super.output_size = 1;
4537 model_lstm->super.is_trainable = is_trainable;
4538 ccv_cnnp_model_copy_name(&model_lstm->super, name);
4539 model_lstm->masked = masked;
4540 model_lstm->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4541 model_lstm->weights.graph = 0;
4542 model_lstm->params.rnn.hidden_size = hidden_size;
4543 model_lstm->params.rnn.proj_size = proj_size;
4544 model_lstm->params.rnn.num_layers = num_layers;
4545 model_lstm->params.rnn.bias = bias;
4546 model_lstm->params.rnn.batch_first = batch_first;
4547 model_lstm->params.rnn.bidirectional = bidirectional;
4548 model_lstm->params.rnn.dropout = dropout;
4549 return (ccv_cnnp_model_t*)model_lstm;
4550}
4551
4552static ccv_cnnp_model_t* _ccv_cnnp_lstm_copy(const ccv_cnnp_model_t* const super, void* const context)
4553{
4554 const ccv_cnnp_model_lstm_t* const self = (const ccv_cnnp_model_lstm_t*)super;
4555 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);
4556}
4557
4558/// MARK - Datatype conversion layer.
4559
4560typedef struct {
4561 ccv_cnnp_model_t super;
4562 ccv_nnc_tensor_symbol_t output;
4563 int datatype;
4564 int ref_to_last;
4565} ccv_cnnp_model_datatype_conversion_t;
4566
4567static 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)
4568{
4569 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
4570 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);
4571 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4572 if (self->ref_to_last)
4573 {
4574 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", 4574, __extension__ __PRETTY_FUNCTION__
); }));
4575 const ccv_nnc_tensor_param_t last_params = ccv_nnc_tensor_symbol_params(graph, inputs[input_size - 1]);
4576 params.datatype = last_params.datatype;
4577 } else
4578 params.datatype = self->datatype;
4579 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", 4579, __extension__ __PRETTY_FUNCTION__
); }));
4580 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4581 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);
4582}
4583
4584static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const self, void* const context);
4585
4586static const ccv_cnnp_model_vtab_t ccv_cnnp_datatype_conversion_isa = {
4587 .build = _ccv_cnnp_datatype_conversion_build,
4588 .copy = _ccv_cnnp_datatype_conversion_copy,
4589};
4590
4591ccv_cnnp_model_t* ccv_cnnp_datatype_conversion(const int datatype, const int ref_to_last, const char* const name)
4592{
4593 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));
4594 model_datatype_conversion->super.isa = &ccv_cnnp_datatype_conversion_isa;
4595 model_datatype_conversion->super.input_size = 0;
4596 model_datatype_conversion->super.outputs = &model_datatype_conversion->output;
4597 model_datatype_conversion->super.output_size = 1;
4598 model_datatype_conversion->datatype = datatype;
4599 model_datatype_conversion->ref_to_last = ref_to_last;
4600 ccv_cnnp_model_copy_name(&model_datatype_conversion->super, name);
4601 return (ccv_cnnp_model_t*)model_datatype_conversion;
4602}
4603
4604static ccv_cnnp_model_t* _ccv_cnnp_datatype_conversion_copy(const ccv_cnnp_model_t* const super, void* const context)
4605{
4606 ccv_cnnp_model_datatype_conversion_t* const self = (ccv_cnnp_model_datatype_conversion_t*)super;
4607 return ccv_cnnp_datatype_conversion(self->datatype, self->ref_to_last, self->super.name);
4608}
4609
4610/// MARK - Clamp layer.
4611
4612typedef struct {
4613 ccv_cnnp_model_t super;
4614 ccv_nnc_tensor_symbol_t output;
4615 float min;
4616 float max;
4617} ccv_cnnp_model_clamp_t;
4618
4619static 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)
4620{
4621 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
4622 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);
4623 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4624 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", 4624, __extension__ __PRETTY_FUNCTION__
); }));
4625 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4626 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);
4627}
4628
4629static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const self, void* const context);
4630
4631static const ccv_cnnp_model_vtab_t ccv_cnnp_clamp_isa = {
4632 .build = _ccv_cnnp_clamp_build,
4633 .copy = _ccv_cnnp_clamp_copy,
4634};
4635
4636ccv_cnnp_model_t* ccv_cnnp_clamp(const float min, const float max, const char* const name)
4637{
4638 ccv_cnnp_model_clamp_t* const model_clamp = (ccv_cnnp_model_clamp_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_clamp_t));
4639 model_clamp->super.isa = &ccv_cnnp_clamp_isa;
4640 model_clamp->super.input_size = 0;
4641 model_clamp->super.outputs = &model_clamp->output;
4642 model_clamp->super.output_size = 1;
4643 model_clamp->min = min;
4644 model_clamp->max = max;
4645 ccv_cnnp_model_copy_name(&model_clamp->super, name);
4646 return (ccv_cnnp_model_t*)model_clamp;
4647}
4648
4649static ccv_cnnp_model_t* _ccv_cnnp_clamp_copy(const ccv_cnnp_model_t* const super, void* const context)
4650{
4651 ccv_cnnp_model_clamp_t* const self = (ccv_cnnp_model_clamp_t*)super;
4652 return ccv_cnnp_clamp(self->min, self->max, self->super.name);
4653}
4654
4655// MARK - Parameter Layer
4656
4657typedef struct {
4658 ccv_cnnp_model_t super;
4659 float init_bound;
4660 ccv_nnc_tensor_symbol_t weights;
4661 ccv_nnc_tensor_param_t weights_params;
4662 ccv_nnc_tensor_symbol_t output;
4663} ccv_cnnp_model_parameter_t;
4664
4665static 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)
4666{
4667 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);
4668 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", 4668, __extension__ __PRETTY_FUNCTION__
); }));
4669 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4670 if (!self->weights.graph)
4671 self->weights = ccv_nnc_tensor_symbol_new(graph, self->weights_params, "weights");
4672 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"
, 4672, __extension__ __PRETTY_FUNCTION__); }));
4673 outputs[0] = ccv_cnnp_model_get_symbol(super, self->weights);
4674}
4675
4676static 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)
4677{
4678 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4679 if (self->init_bound > 0)
4680 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);
4681 else
4682 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);
4683}
4684
4685static 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)
4686{
4687 ccv_cnnp_model_parameter_t* const self = (ccv_cnnp_model_parameter_t*)super;
4688 add_to_array(parameters, self->weights, is_trainable);
4689}
4690
4691static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context);
4692
4693static const ccv_cnnp_model_vtab_t ccv_cnnp_parameter_isa = {
4694 .build = _ccv_cnnp_parameter_build,
4695 .init_states = _ccv_cnnp_parameter_init_states,
4696 .add_to_parameter = _ccv_cnnp_parameter_add_to_parameter,
4697 .copy = _ccv_cnnp_parameter_copy,
4698};
4699
4700ccv_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)
4701{
4702 ccv_cnnp_model_parameter_t* const model_parameter = (ccv_cnnp_model_parameter_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_parameter_t));
4703 model_parameter->super.isa = &ccv_cnnp_parameter_isa;
4704 model_parameter->super.input_size = 0;
4705 model_parameter->super.outputs = &model_parameter->output;
4706 model_parameter->super.output_size = 1;
4707 model_parameter->super.is_trainable = is_trainable;
4708 ccv_cnnp_model_copy_name(&model_parameter->super, name);
4709 model_parameter->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
4710 model_parameter->weights.graph = 0;
4711 model_parameter->weights_params = params;
4712 return (ccv_cnnp_model_t*)model_parameter;
4713}
4714
4715static ccv_cnnp_model_t* _ccv_cnnp_parameter_copy(const ccv_cnnp_model_t* const super, void* const context)
4716{
4717 const ccv_cnnp_model_parameter_t* const self = (const ccv_cnnp_model_parameter_t*)super;
4718 return ccv_cnnp_parameter(self->weights_params, self->init_bound, self->super.is_trainable, self->super.name);
4719}
4720
4721// MARK - Scalar Layer
4722
4723typedef struct {
4724 ccv_cnnp_model_t super;
4725 int type;
4726 int format;
4727 int datatype;
4728 float value;
4729 ccv_nnc_tensor_symbol_t output;
4730} ccv_cnnp_model_scalar_t;
4731
4732static 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)
4733{
4734 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);
4735 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", 4735, __extension__ __PRETTY_FUNCTION__
); }));
4736 ccv_cnnp_model_scalar_t* const self = (ccv_cnnp_model_scalar_t*)super;
4737 ccv_nnc_tensor_param_t params = {
4738 .type = self->type,
4739 .format = self->format,
4740 .datatype = self->datatype,
4741 .dim = {
4742 1
4743 }
4744 };
4745 if (input_size > 0)
4746 {
4747 ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4748 params.type = input_params.type;
4749 params.format = input_params.format;
4750 params.datatype = input_params.datatype;
4751 }
4752 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4753 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);
4754}
4755
4756static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context);
4757
4758static const ccv_cnnp_model_vtab_t ccv_cnnp_scalar_isa = {
4759 .build = _ccv_cnnp_scalar_build,
4760 .copy = _ccv_cnnp_scalar_copy,
4761};
4762
4763ccv_cnnp_model_t* ccv_cnnp_scalar(const int type, const int format, const int datatype, const float value, const char* const name)
4764{
4765 ccv_cnnp_model_scalar_t* const model_scalar = (ccv_cnnp_model_scalar_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_scalar_t));
4766 model_scalar->super.isa = &ccv_cnnp_scalar_isa;
4767 model_scalar->super.input_size = 0;
4768 model_scalar->super.outputs = &model_scalar->output;
4769 model_scalar->super.output_size = 1;
4770 ccv_cnnp_model_copy_name(&model_scalar->super, name);
4771 model_scalar->type = type;
4772 model_scalar->format = format;
4773 model_scalar->datatype = datatype;
4774 model_scalar->value = value;
4775 return (ccv_cnnp_model_t*)model_scalar;
4776}
4777
4778static ccv_cnnp_model_t* _ccv_cnnp_scalar_copy(const ccv_cnnp_model_t* const super, void* const context)
4779{
4780 const ccv_cnnp_model_scalar_t* const self = (const ccv_cnnp_model_scalar_t*)super;
4781 return ccv_cnnp_scalar(self->type, self->format, self->datatype, self->value, self->super.name);
4782}
4783
4784// MARK - Variable Layer
4785
4786typedef struct {
4787 ccv_cnnp_model_t super;
4788 ccv_nnc_tensor_param_t params;
4789 ccv_nnc_tensor_symbol_t output;
4790} ccv_cnnp_model_variable_t;
4791
4792static 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)
4793{
4794 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);
4795 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"
, 4795, __extension__ __PRETTY_FUNCTION__); }));
4796 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", 4796, __extension__ __PRETTY_FUNCTION__
); }));
4797 ccv_cnnp_model_variable_t* const self = (ccv_cnnp_model_variable_t*)super;
4798 outputs[0] = ccv_nnc_tensor_symbol_new(graph, self->params, 0);
4799}
4800
4801static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context);
4802
4803static const ccv_cnnp_model_vtab_t ccv_cnnp_variable_isa = {
4804 .build = _ccv_cnnp_variable_build,
4805 .copy = _ccv_cnnp_variable_copy,
4806};
4807
4808ccv_cnnp_model_t* ccv_cnnp_variable(const ccv_nnc_tensor_param_t params, const char* const name)
4809{
4810 ccv_cnnp_model_variable_t* const model_variable = (ccv_cnnp_model_variable_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_variable_t));
4811 model_variable->super.isa = &ccv_cnnp_variable_isa;
4812 model_variable->super.input_size = 0;
4813 model_variable->super.outputs = &model_variable->output;
4814 model_variable->super.output_size = 1;
4815 ccv_cnnp_model_copy_name(&model_variable->super, name);
4816 model_variable->params = params;
4817 return (ccv_cnnp_model_t*)model_variable;
4818}
4819
4820static ccv_cnnp_model_t* _ccv_cnnp_variable_copy(const ccv_cnnp_model_t* const super, void* const context)
4821{
4822 const ccv_cnnp_model_variable_t* const self = (const ccv_cnnp_model_variable_t*)super;
4823 return ccv_cnnp_variable(self->params, self->super.name);
4824}
4825
4826// MARK - Set Layer
4827
4828typedef struct {
4829 ccv_cnnp_model_t super;
4830 float value;
4831 ccv_nnc_tensor_symbol_t output;
4832} ccv_cnnp_model_set_t;
4833
4834static 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)
4835{
4836 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);
4837 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"
, 4837, __extension__ __PRETTY_FUNCTION__); }));
4838 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", 4838, __extension__ __PRETTY_FUNCTION__
); }));
4839 ccv_cnnp_model_set_t* const self = (ccv_cnnp_model_set_t*)super;
4840 outputs[0] = inputs[0];
4841 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");
4842}
4843
4844static ccv_cnnp_model_t* _ccv_cnnp_set_copy(const ccv_cnnp_model_t* const super, void* const context);
4845
4846static const ccv_cnnp_model_vtab_t ccv_cnnp_set_isa = {
4847 .build = _ccv_cnnp_set_build,
4848 .copy = _ccv_cnnp_set_copy,
4849};
4850
4851ccv_cnnp_model_t* ccv_cnnp_set(const float value, const char* const name)
4852{
4853 ccv_cnnp_model_set_t* const model_set = (ccv_cnnp_model_set_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_set_t));
4854 model_set->super.isa = &ccv_cnnp_set_isa;
4855 model_set->super.input_size = 1;
4856 model_set->super.outputs = &model_set->output;
4857 model_set->super.output_size = 1;
4858 ccv_cnnp_model_copy_name(&model_set->super, name);
4859 model_set->value = value;
4860 return (ccv_cnnp_model_t*)model_set;
4861}
4862
4863static ccv_cnnp_model_t* _ccv_cnnp_set_copy(const ccv_cnnp_model_t* const super, void* const context)
4864{
4865 const ccv_cnnp_model_set_t* const self = (const ccv_cnnp_model_set_t*)super;
4866 return ccv_cnnp_set(self->value, self->super.name);
4867}
4868
4869// MARK - Send Layer
4870
4871typedef struct {
4872 ccv_cnnp_model_t super;
4873 int device_id;
4874 ccv_nnc_tensor_symbol_t output;
4875} ccv_cnnp_model_send_t;
4876
4877static 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)
4878{
4879 ccv_cnnp_model_send_t* const self = (ccv_cnnp_model_send_t*)super;
4880 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);
4881 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"
, 4881, __extension__ __PRETTY_FUNCTION__); }));
4882 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", 4882, __extension__ __PRETTY_FUNCTION__
); }));
4883 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4884 params.type = (params.type & ~0x3) | CCV_TENSOR_GPU_MEMORY;
4885 CCV_TENSOR_SET_DEVICE_ID(params.type, self->device_id)(params.type) = (((params.type) & ~0xfff00) | (((self->
device_id) & 0xfff) << 8));
4886 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4887 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");
4888}
4889
4890static ccv_cnnp_model_t* _ccv_cnnp_send_copy(const ccv_cnnp_model_t* const super, void* const context);
4891
4892static const ccv_cnnp_model_vtab_t ccv_cnnp_send_isa = {
4893 .build = _ccv_cnnp_send_build,
4894 .copy = _ccv_cnnp_send_copy,
4895};
4896
4897ccv_cnnp_model_t* ccv_cnnp_send(const int device_id, const char* const name)
4898{
4899 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", 4899, __extension__ __PRETTY_FUNCTION__
); }));
4900 ccv_cnnp_model_send_t* const model_send = (ccv_cnnp_model_send_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_send_t));
4901 model_send->super.isa = &ccv_cnnp_send_isa;
4902 model_send->super.input_size = 1;
4903 model_send->super.outputs = &model_send->output;
4904 model_send->super.output_size = 1;
4905 ccv_cnnp_model_copy_name(&model_send->super, name);
4906 model_send->device_id = device_id;
4907 return (ccv_cnnp_model_t*)model_send;
4908}
4909
4910static ccv_cnnp_model_t* _ccv_cnnp_send_copy(const ccv_cnnp_model_t* const super, void* const context)
4911{
4912 const ccv_cnnp_model_send_t* const self = (const ccv_cnnp_model_send_t*)super;
4913 return ccv_cnnp_send(self->device_id, self->super.name);
4914}
4915
4916// MARK - Move Layer
4917
4918typedef struct {
4919 ccv_cnnp_model_t super;
4920 ccv_nnc_tensor_symbol_t output;
4921} ccv_cnnp_model_move_t;
4922
4923static 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)
4924{
4925 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);
4926 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"
, 4926, __extension__ __PRETTY_FUNCTION__); }));
4927 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", 4927, __extension__ __PRETTY_FUNCTION__
); }));
4928 outputs[0] = inputs[1];
4929 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");
4930}
4931
4932static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context);
4933
4934static const ccv_cnnp_model_vtab_t ccv_cnnp_move_isa = {
4935 .build = _ccv_cnnp_move_build,
4936 .copy = _ccv_cnnp_move_copy,
4937};
4938
4939ccv_cnnp_model_t* ccv_cnnp_move(const char* const name)
4940{
4941 ccv_cnnp_model_move_t* const model_move = (ccv_cnnp_model_move_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_move_t));
4942 model_move->super.isa = &ccv_cnnp_move_isa;
4943 model_move->super.input_size = 2;
4944 model_move->super.outputs = &model_move->output;
4945 model_move->super.output_size = 1;
4946 ccv_cnnp_model_copy_name(&model_move->super, name);
4947 return (ccv_cnnp_model_t*)model_move;
4948}
4949
4950static ccv_cnnp_model_t* _ccv_cnnp_move_copy(const ccv_cnnp_model_t* const super, void* const context)
4951{
4952 const ccv_cnnp_model_move_t* const self = (const ccv_cnnp_model_move_t*)super;
4953 return ccv_cnnp_move(self->super.name);
4954}
4955
4956// MARK - "Making" Contiguous Layer
4957
4958typedef struct {
4959 ccv_cnnp_model_t super;
4960 ccv_nnc_tensor_symbol_t output;
4961} ccv_cnnp_model_contiguous_t;
4962
4963static 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)
4964{
4965 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);
4966 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"
, 4966, __extension__ __PRETTY_FUNCTION__); }));
4967 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", 4967, __extension__ __PRETTY_FUNCTION__
); }));
4968 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
4969 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
4970 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
4971 {
4972 outputs[0] = inputs[0];
4973 return;
4974 }
4975 // Otherwise, we need to check its stride to know if it is contiguous.
4976 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
4977 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], 0, old_stride);
4978 // We identify permute by checking if the stride is not in descending order.
4979 // This also covered "permute" through reshape, rather than using ccv_cnnp_permute directly.
4980 if (ccv_nnc_is_tensor_stride_packed(old_stride, params.dim))
4981 {
4982 outputs[0] = inputs[0];
4983 return;
4984 }
4985 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
4986 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");
4987 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
4988}
4989
4990static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context);
4991
4992static const ccv_cnnp_model_vtab_t ccv_cnnp_contiguous_isa = {
4993 .build = _ccv_cnnp_contiguous_build,
4994 .copy = _ccv_cnnp_contiguous_copy,
4995};
4996
4997ccv_cnnp_model_t* ccv_cnnp_contiguous(const char* const name)
4998{
4999 ccv_cnnp_model_contiguous_t* const model_contiguous = (ccv_cnnp_model_contiguous_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_contiguous_t));
5000 model_contiguous->super.isa = &ccv_cnnp_contiguous_isa;
5001 model_contiguous->super.input_size = 1;
5002 model_contiguous->super.outputs = &model_contiguous->output;
5003 model_contiguous->super.output_size = 1;
5004 ccv_cnnp_model_copy_name(&model_contiguous->super, name);
5005 return (ccv_cnnp_model_t*)model_contiguous;
5006}
5007
5008static ccv_cnnp_model_t* _ccv_cnnp_contiguous_copy(const ccv_cnnp_model_t* const super, void* const context)
5009{
5010 const ccv_cnnp_model_contiguous_t* const self = (const ccv_cnnp_model_contiguous_t*)super;
5011 return ccv_cnnp_contiguous(self->super.name);
5012}
5013
5014// MARK - "Making" Copy Layer
5015
5016typedef struct {
5017 ccv_cnnp_model_t super;
5018 ccv_nnc_tensor_symbol_t output;
5019} ccv_cnnp_model_copy_t;
5020
5021static 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)
5022{
5023 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);
5024 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"
, 5024, __extension__ __PRETTY_FUNCTION__); }));
5025 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", 5025, __extension__ __PRETTY_FUNCTION__
); }));
5026 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5027 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
5028 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
5029 {
5030 outputs[0] = inputs[0];
5031 return;
5032 }
5033 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5034 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");
5035 ccv_nnc_graph_exec_symbol_set_flags(graph, make_contiguous, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
5036}
5037
5038static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context);
5039
5040static const ccv_cnnp_model_vtab_t ccv_cnnp_copy_isa = {
5041 .build = _ccv_cnnp_copy_build,
5042 .copy = _ccv_cnnp_copy_copy,
5043};
5044
5045ccv_cnnp_model_t* ccv_cnnp_copy(const char* const name)
5046{
5047 ccv_cnnp_model_copy_t* const model_copy = (ccv_cnnp_model_copy_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_copy_t));
5048 model_copy->super.isa = &ccv_cnnp_copy_isa;
5049 model_copy->super.input_size = 1;
5050 model_copy->super.outputs = &model_copy->output;
5051 model_copy->super.output_size = 1;
5052 ccv_cnnp_model_copy_name(&model_copy->super, name);
5053 return (ccv_cnnp_model_t*)model_copy;
5054}
5055
5056static ccv_cnnp_model_t* _ccv_cnnp_copy_copy(const ccv_cnnp_model_t* const super, void* const context)
5057{
5058 const ccv_cnnp_model_copy_t* const self = (const ccv_cnnp_model_copy_t*)super;
5059 return ccv_cnnp_copy(self->super.name);
5060}
5061
5062// MARK - All-To-All Layer
5063
5064typedef struct {
5065 ccv_cnnp_model_t super;
5066 int axis;
5067 ccv_nnc_tensor_symbol_t outputs[1];
5068} ccv_cnnp_model_all_to_all_t;
5069
5070static 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)
5071{
5072 ccv_cnnp_model_all_to_all_t* const self = (ccv_cnnp_model_all_to_all_t*)super;
5073 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);
5074 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", 5074, __extension__ __PRETTY_FUNCTION__
); }));
5075 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", 5075, __extension__ __PRETTY_FUNCTION__
); }));
5076 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", 5076, __extension__ __PRETTY_FUNCTION__
); }));
5077 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", 5077, __extension__ __PRETTY_FUNCTION__
); }));
5078 const ccv_nnc_tensor_param_t input_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5079 const int nd = ccv_nnc_tensor_nd(input_params.dim);
5080 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", 5080, __extension__ __PRETTY_FUNCTION__
); }));
5081 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", 5081, __extension__ __PRETTY_FUNCTION__
); }));
5082 int i;
5083 for (i = 0; i < input_size; i++)
5084 {
5085 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
5086 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", 5086, __extension__ __PRETTY_FUNCTION__
); }));
5087 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", 5087, __extension__ __PRETTY_FUNCTION__
); }));
5088 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", 5088, __extension__ __PRETTY_FUNCTION__
); }));
5089 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", 5089, __extension__ __PRETTY_FUNCTION__
); }));
5090 outputs[i] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5091 }
5092 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");
5093}
5094
5095static ccv_cnnp_model_t* _ccv_cnnp_all_to_all_copy(const ccv_cnnp_model_t* const super, void* const context);
5096
5097static const ccv_cnnp_model_vtab_t ccv_cnnp_all_to_all_isa = {
5098 .build = _ccv_cnnp_all_to_all_build,
5099 .copy = _ccv_cnnp_all_to_all_copy,
5100};
5101
5102ccv_cnnp_model_t* ccv_cnnp_all_to_all(const int count, const int axis, const char* const name)
5103{
5104 assert(count > 0)((void) sizeof ((count > 0) ? 1 : 0), __extension__ ({ if (
count > 0) ; else __assert_fail ("count > 0", "ccv_cnnp_model_addons.c"
, 5104, __extension__ __PRETTY_FUNCTION__); }));
5105 assert(axis >= 0)((void) sizeof ((axis >= 0) ? 1 : 0), __extension__ ({ if (
axis >= 0) ; else __assert_fail ("axis >= 0", "ccv_cnnp_model_addons.c"
, 5105, __extension__ __PRETTY_FUNCTION__); }));
5106 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));
5107 model_all_to_all->super.isa = &ccv_cnnp_all_to_all_isa;
5108 model_all_to_all->super.input_size = count;
5109 model_all_to_all->super.outputs = model_all_to_all->outputs;
5110 model_all_to_all->super.output_size = count;
5111 model_all_to_all->axis = axis;
5112 ccv_cnnp_model_copy_name(&model_all_to_all->super, name);
5113 return (ccv_cnnp_model_t*)model_all_to_all;
5114}
5115
5116static ccv_cnnp_model_t* _ccv_cnnp_all_to_all_copy(const ccv_cnnp_model_t* const super, void* const context)
5117{
5118 const ccv_cnnp_model_all_to_all_t* const self = (const ccv_cnnp_model_all_to_all_t*)super;
5119 return ccv_cnnp_all_to_all(self->super.output_size, self->axis, self->super.name);
5120}
5121
5122// MARK - Scaled-Dot Product Attention Layer
5123
5124typedef struct {
5125 ccv_cnnp_model_t super;
5126 ccv_nnc_tensor_symbol_t output;
5127 ccv_nnc_tensor_symbol_t weights;
5128 ccv_nnc_tensor_symbol_t bias;
5129 float scale;
5130 int is_causal;
5131 int has_attn_mask;
5132 int is_varlen;
5133 int max_seqlen_q;
5134 int max_seqlen_kv;
5135 int flags;
5136 int use_hadamard;
5137 int attention_sinks;
5138 int sliding_window;
5139 int fused_unify_head_weights;
5140 int no_bias;
5141} ccv_cnnp_model_scaled_dot_product_attention_t;
5142
5143static 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)
5144{
5145 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);
5146 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", 5146, __extension__ __PRETTY_FUNCTION__
); }));
5147 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5148 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", 5148, __extension__ __PRETTY_FUNCTION__
); }));
5149 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", 5149, __extension__ __PRETTY_FUNCTION__
); }));
5150 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", 5150, __extension__ __PRETTY_FUNCTION__
); }));
5151 const ccv_nnc_tensor_param_t q_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5152 const ccv_nnc_tensor_param_t k_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
5153 const ccv_nnc_tensor_param_t v_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
5154 const int sink_idx = self->is_varlen ? 5 : (3 + self->has_attn_mask);
5155 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){};
5156 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){};
5157 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){};
5158 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){};
5159 const int v_nd = ccv_nnc_tensor_nd(v_params.dim);
5160 // 0-length values have no rank, the command infers 0-length outputs from them.
5161 assert(v_nd == 3 || v_nd == 4 || v_params.dim[0] == 0)((void) sizeof ((v_nd == 3 || v_nd == 4 || v_params.dim[0] ==
0) ? 1 : 0), __extension__ ({ if (v_nd == 3 || v_nd == 4 || v_params
.dim[0] == 0) ; else __assert_fail ("v_nd == 3 || v_nd == 4 || v_params.dim[0] == 0"
, "ccv_cnnp_model_addons.c", 5161, __extension__ __PRETTY_FUNCTION__
); }));
5162 const int hEv = v_nd == 0 ? 0 : (v_nd == 3 ? 1 : v_params.dim[2]) * v_params.dim[v_nd - 1];
5163 ccv_nnc_tensor_param_t weights_params = q_params;
5164 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5165 weights_params.dim[0] = hEv;
5166 weights_params.dim[1] = hEv;
5167 ccv_nnc_tensor_param_t bias_params = q_params;
5168 memset(bias_params.dim, 0, sizeof(bias_params.dim));
5169 bias_params.dim[0] = hEv;
5170 ccv_nnc_cmd_t cmd = {0};
5171 cmd.cmd = CCV_NNC_SCALED_DOT_PRODUCT_ATTENTION_FORWARD;
5172 cmd.info.scaled_dot_product_attention.scale = self->scale;
5173 cmd.info.scaled_dot_product_attention.is_causal = self->is_causal;
5174 cmd.info.scaled_dot_product_attention.is_varlen = self->is_varlen;
5175 cmd.info.scaled_dot_product_attention.max_seqlen_q = self->max_seqlen_q;
5176 cmd.info.scaled_dot_product_attention.max_seqlen_kv = self->max_seqlen_kv;
5177 cmd.info.scaled_dot_product_attention.flags = self->flags;
5178 cmd.info.scaled_dot_product_attention.use_hadamard = self->use_hadamard;
5179 cmd.info.scaled_dot_product_attention.attention_sinks = self->attention_sinks;
5180 cmd.info.scaled_dot_product_attention.sliding_window = self->sliding_window;
5181 ccv_nnc_tensor_param_t output_params[3];
5182 ccv_nnc_tensor_symbol_t output;
5183 ccv_nnc_tensor_symbol_t saved_softmax_lse;
5184 ccv_nnc_tensor_symbol_t saved_v_proj = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5185 ccv_nnc_tensor_symbol_t attn_mask = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5186 ccv_nnc_tensor_symbol_t weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5187 ccv_nnc_tensor_symbol_t bias = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5188 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
};
5189 if (self->has_attn_mask)
5190 attn_mask = inputs[3];
5191 if (self->is_varlen)
5192 {
5193 ccv_nnc_tensor_param_t input_params[9] = {
5194 q_params,
5195 k_params,
5196 v_params,
5197 (ccv_nnc_tensor_param_t){},
5198 (ccv_nnc_tensor_param_t){},
5199 (ccv_nnc_tensor_param_t){},
5200 q_seq_offsets_params,
5201 kv_seq_offsets_params,
5202 sinks_params,
5203 };
5204 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 8, ccv_nnc_no_hint, output_params, 2);
5205 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
5206 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
5207 if (self->attention_sinks)
5208 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");
5209 else
5210 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");
5211 } else if (self->fused_unify_head_weights)
5212 {
5213 if (!self->weights.graph)
5214 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
5215 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"
, 5215, __extension__ __PRETTY_FUNCTION__); }));
5216 weights = ccv_cnnp_model_get_symbol(super, self->weights);
5217 if (!self->no_bias)
5218 {
5219 if (!self->bias.graph)
5220 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
5221 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", 5221, __extension__ __PRETTY_FUNCTION__
); }));
5222 bias = ccv_cnnp_model_get_symbol(super, self->bias);
5223 }
5224 ccv_nnc_tensor_param_t input_params[9] = {
5225 q_params,
5226 k_params,
5227 v_params,
5228 attn_mask_params,
5229 weights_params,
5230 bias_params,
5231 (ccv_nnc_tensor_param_t){},
5232 (ccv_nnc_tensor_param_t){},
5233 sinks_params,
5234 };
5235 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 6, ccv_nnc_no_hint, output_params, 3);
5236 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
5237 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
5238 saved_v_proj = ccv_nnc_tensor_symbol_new(graph, output_params[2], 0);
5239 if (self->attention_sinks)
5240 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");
5241 else
5242 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");
5243 } else {
5244 ccv_nnc_tensor_param_t input_params[9] = {
5245 q_params,
5246 k_params,
5247 v_params,
5248 attn_mask_params,
5249 (ccv_nnc_tensor_param_t){},
5250 (ccv_nnc_tensor_param_t){},
5251 (ccv_nnc_tensor_param_t){},
5252 (ccv_nnc_tensor_param_t){},
5253 sinks_params,
5254 };
5255 ccv_nnc_hint_tensor_auto(cmd, input_params, self->attention_sinks ? 9 : 3, ccv_nnc_no_hint, output_params, 2);
5256 output = ccv_nnc_tensor_symbol_new(graph, output_params[0], 0);
5257 saved_softmax_lse = ccv_nnc_tensor_symbol_new(graph, output_params[1], 0);
5258 if (self->attention_sinks)
5259 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");
5260 else
5261 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");
5262 }
5263 outputs[0] = output;
5264}
5265
5266static 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)
5267{
5268 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5269 if (self->weights.graph)
5270 {
5271 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"
, 5271, __extension__ __PRETTY_FUNCTION__); }));
5272 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
5273 const int c = weight_params.dim[1];
5274 const float std = sqrtf(2) / sqrtf(c);
5275 const float bound = sqrtf(3) * std;
5276 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);
5277 if (self->bias.graph)
5278 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);
5279 }
5280}
5281
5282static 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)
5283{
5284 ccv_cnnp_model_scaled_dot_product_attention_t* const self = (ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5285 if (self->weights.graph)
5286 {
5287 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"
, 5287, __extension__ __PRETTY_FUNCTION__); }));
5288 add_to_array(parameters, self->weights, is_trainable);
5289 if (self->bias.graph)
5290 add_to_array(parameters, self->bias, is_trainable);
5291 }
5292}
5293
5294static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context);
5295
5296static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_isa = {
5297 .build = _ccv_cnnp_scaled_dot_product_attention_build,
5298 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
5299};
5300
5301static const ccv_cnnp_model_vtab_t ccv_cnnp_scaled_dot_product_attention_fused_isa = {
5302 .build = _ccv_cnnp_scaled_dot_product_attention_build,
5303 .init_states = _ccv_cnnp_scaled_dot_product_attention_init_states,
5304 .add_to_parameter = _ccv_cnnp_scaled_dot_product_attention_add_to_parameter,
5305 .copy = _ccv_cnnp_scaled_dot_product_attention_copy,
5306};
5307
5308ccv_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 use_hadamard, 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)
5309{
5310 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", 5310, __extension__ __PRETTY_FUNCTION__
); }));
5311 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", 5311, __extension__ __PRETTY_FUNCTION__
); }));
5312 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"
, 5312, __extension__ __PRETTY_FUNCTION__); }));
5313 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"
, 5313, __extension__ __PRETTY_FUNCTION__); }));
5314 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));
5315 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;
5316 const int has_attention_sinks = attention_sinks ? 1 : 0;
5317 model_scaled_dot_product_attention->super.input_size = (is_varlen ? 5 : (has_attn_mask ? 4 : 3)) + has_attention_sinks;
5318 model_scaled_dot_product_attention->super.outputs = &model_scaled_dot_product_attention->output;
5319 model_scaled_dot_product_attention->super.output_size = 1;
5320 model_scaled_dot_product_attention->super.is_trainable = is_trainable;
5321 ccv_cnnp_model_copy_name(&model_scaled_dot_product_attention->super, name);
5322 model_scaled_dot_product_attention->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5323 model_scaled_dot_product_attention->weights.graph = 0;
5324 model_scaled_dot_product_attention->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
5325 model_scaled_dot_product_attention->bias.graph = 0;
5326 model_scaled_dot_product_attention->scale = scale;
5327 model_scaled_dot_product_attention->is_causal = is_causal;
5328 model_scaled_dot_product_attention->has_attn_mask = has_attn_mask;
5329 model_scaled_dot_product_attention->is_varlen = is_varlen;
5330 model_scaled_dot_product_attention->max_seqlen_q = max_seqlen_q;
5331 model_scaled_dot_product_attention->max_seqlen_kv = max_seqlen_kv;
5332 model_scaled_dot_product_attention->flags = flags;
5333 model_scaled_dot_product_attention->use_hadamard = use_hadamard;
5334 model_scaled_dot_product_attention->attention_sinks = has_attention_sinks;
5335 model_scaled_dot_product_attention->sliding_window = sliding_window;
5336 model_scaled_dot_product_attention->fused_unify_head_weights = fused_unify_head_weights;
5337 model_scaled_dot_product_attention->no_bias = no_bias;
5338 return (ccv_cnnp_model_t*)model_scaled_dot_product_attention;
5339}
5340
5341static ccv_cnnp_model_t* _ccv_cnnp_scaled_dot_product_attention_copy(const ccv_cnnp_model_t* const super, void* const context)
5342{
5343 const ccv_cnnp_model_scaled_dot_product_attention_t* const self = (const ccv_cnnp_model_scaled_dot_product_attention_t*)super;
5344 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->use_hadamard, self->attention_sinks, self->sliding_window, self->fused_unify_head_weights, self->no_bias, self->super.is_trainable, self->super.name);
5345}
5346
5347// MARK - Debug Layer
5348
5349typedef struct {
5350 ccv_cnnp_model_t super;
5351 ccv_nnc_tensor_symbol_t output;
5352 ccv_cnnp_model_debug_f debugger;
5353 ccv_cnnp_model_debug_context_deinit_f debug_deinit;
5354 ccv_cnnp_model_debug_context_copy_f debug_copy;
5355 void* debug_context;
5356} ccv_cnnp_model_debug_t;
5357
5358static 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)
5359{
5360 if (cmd.cmd == CCV_NNC_CUSTOM_BACKWARD)
5361 {
5362 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", 5362, __extension__ __PRETTY_FUNCTION__
); }));
5363 }
5364 ccv_cnnp_model_debug_t* const self = (ccv_cnnp_model_debug_t*)cmd.data;
5365 self->debugger(inputs, input_size, stream_context, self->debug_context);
5366 return CCV_NNC_EXEC_SUCCESS;
5367}
5368
5369static ccv_nnc_cmd_vtab_t ccv_cnnp_debug_exec_isa = {
5370 .exec = _ccv_cnnp_debug_exec
5371};
5372
5373static 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)
5374{
5375 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);
5376 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", 5376, __extension__ __PRETTY_FUNCTION__
); }));
5377 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", 5377, __extension__ __PRETTY_FUNCTION__
); }));
5378 ccv_nnc_tensor_symbol_t to = ccv_nnc_tensor_symbol_alias_to(graph, inputs[0]);
5379 ccv_nnc_tensor_param_t output_params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5380 if (to.d == CCV_NNC_NO_TENSOR_SYMBOL) // If we are not reshape an alias, it is straightforward.
5381 {
5382 int ofs[CCV_NNC_MAX_DIM_ALLOC(12)] = {0};
5383 int stride[CCV_NNC_MAX_DIM_ALLOC(12)];
5384 ccv_nnc_tensor_get_stride(output_params.dim, stride);
5385 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, inputs[0], ofs, stride, output_params, 0);
5386 } else {
5387 int old_ofs[CCV_NNC_MAX_DIM_ALLOC(12)];
5388 int old_stride[CCV_NNC_MAX_DIM_ALLOC(12)];
5389 ccv_nnc_tensor_symbol_alias_params(graph, inputs[0], old_ofs, old_stride);
5390 outputs[0] = ccv_nnc_tensor_symbol_alias_new(graph, to, old_ofs, old_stride, output_params, 0);
5391 }
5392 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);
5393 cmd.data = self;
5394 ccv_nnc_graph_exec_symbol_t make_debug = ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, input_size, outputs, 1, "debug");
5395 // Disable any optimizations.
5396 ccv_nnc_graph_exec_symbol_set_flags(graph, make_debug, CCV_NNC_GRAPH_EXEC_DISABLE_OPT);
5397}
5398
5399static void _ccv_cnnp_debug_deinit(ccv_cnnp_model_t* const super)
5400{
5401 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
5402 if (self->debug_deinit && self->debug_context)
5403 self->debug_deinit(self->debug_context);
5404}
5405
5406static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context);
5407
5408static const ccv_cnnp_model_vtab_t ccv_cnnp_debug_isa = {
5409 .build = _ccv_cnnp_debug_build,
5410 .deinit = _ccv_cnnp_debug_deinit,
5411 .copy = _ccv_cnnp_debug_copy,
5412};
5413
5414ccv_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)
5415{
5416 ccv_cnnp_model_debug_t* const model_debug = (ccv_cnnp_model_debug_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_debug_t));
5417 model_debug->super.isa = &ccv_cnnp_debug_isa;
5418 model_debug->super.input_size = 0;
5419 model_debug->super.outputs = &model_debug->output;
5420 model_debug->super.output_size = 1;
5421 model_debug->debugger = func;
5422 model_debug->debug_context = context;
5423 model_debug->debug_deinit = deinit;
5424 model_debug->debug_copy = copy;
5425 ccv_cnnp_model_copy_name(&model_debug->super, name);
5426 return (ccv_cnnp_model_t*)model_debug;
5427}
5428
5429static ccv_cnnp_model_t* _ccv_cnnp_debug_copy(const ccv_cnnp_model_t* const super, void* const context)
5430{
5431 const ccv_cnnp_model_debug_t* const self = (const ccv_cnnp_model_debug_t*)super;
5432 void* debug_context = self->debug_context;
5433 if (self->debug_copy && self->debug_context)
5434 debug_context = self->debug_copy(self->debug_context);
5435 return ccv_cnnp_debug(self->debugger, debug_context, self->debug_deinit, self->debug_copy, self->super.name);
5436}
5437
5438/// MARK - Sort layer.
5439
5440typedef struct {
5441 ccv_cnnp_model_t super;
5442 ccv_nnc_tensor_symbol_t outputs[2];
5443 int along_axis;
5444 int descending;
5445} ccv_cnnp_model_sort_t;
5446
5447static 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)
5448{
5449 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
5450 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);
5451 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5452 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", 5452, __extension__ __PRETTY_FUNCTION__
); }));
5453 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5454 params.datatype = CCV_32S;
5455 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5456 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");
5457}
5458
5459static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const self, void* const context);
5460
5461static const ccv_cnnp_model_vtab_t ccv_cnnp_sort_isa = {
5462 .build = _ccv_cnnp_sort_build,
5463 .copy = _ccv_cnnp_sort_copy,
5464};
5465
5466ccv_cnnp_model_t* ccv_cnnp_sort(const int along_axis, const int descending, const char* const name)
5467{
5468 ccv_cnnp_model_sort_t* const model_sort = (ccv_cnnp_model_sort_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_sort_t));
5469 model_sort->super.isa = &ccv_cnnp_sort_isa;
5470 model_sort->super.input_size = 0;
5471 model_sort->super.outputs = model_sort->outputs;
5472 model_sort->super.output_size = 2;
5473 model_sort->along_axis = along_axis;
5474 model_sort->descending = descending;
5475 ccv_cnnp_model_copy_name(&model_sort->super, name);
5476 return (ccv_cnnp_model_t*)model_sort;
5477}
5478
5479static ccv_cnnp_model_t* _ccv_cnnp_sort_copy(const ccv_cnnp_model_t* const super, void* const context)
5480{
5481 ccv_cnnp_model_sort_t* const self = (ccv_cnnp_model_sort_t*)super;
5482 return ccv_cnnp_sort(self->along_axis, self->descending, self->super.name);
5483}
5484
5485/// MARK - Partition layer.
5486
5487typedef struct {
5488 ccv_cnnp_model_t super;
5489 ccv_nnc_tensor_symbol_t outputs[2];
5490 int kth;
5491 int along_axis;
5492 int descending;
5493} ccv_cnnp_model_partition_t;
5494
5495static 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)
5496{
5497 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
5498 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);
5499 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5500 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", 5500, __extension__ __PRETTY_FUNCTION__
); }));
5501 if (self->kth > 0)
5502 params.dim[self->along_axis] = self->kth;
5503 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5504 params.datatype = CCV_32S;
5505 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5506 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");
5507}
5508
5509static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const self, void* const context);
5510
5511static const ccv_cnnp_model_vtab_t ccv_cnnp_partition_isa = {
5512 .build = _ccv_cnnp_partition_build,
5513 .copy = _ccv_cnnp_partition_copy,
5514};
5515
5516ccv_cnnp_model_t* ccv_cnnp_partition(const int kth, const int along_axis, const int descending, const char* const name)
5517{
5518 ccv_cnnp_model_partition_t* const model_partition = (ccv_cnnp_model_partition_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_partition_t));
5519 model_partition->super.isa = &ccv_cnnp_partition_isa;
5520 model_partition->super.input_size = 0;
5521 model_partition->super.outputs = model_partition->outputs;
5522 model_partition->super.output_size = 2;
5523 model_partition->kth = kth;
5524 model_partition->along_axis = along_axis;
5525 model_partition->descending = descending;
5526 ccv_cnnp_model_copy_name(&model_partition->super, name);
5527 return (ccv_cnnp_model_t*)model_partition;
5528}
5529
5530static ccv_cnnp_model_t* _ccv_cnnp_partition_copy(const ccv_cnnp_model_t* const super, void* const context)
5531{
5532 ccv_cnnp_model_partition_t* const self = (ccv_cnnp_model_partition_t*)super;
5533 return ccv_cnnp_partition(self->kth, self->along_axis, self->descending, self->super.name);
5534}
5535
5536/// MARK - Unique consecutive layer.
5537
5538typedef struct {
5539 ccv_cnnp_model_t super;
5540 ccv_nnc_tensor_symbol_t outputs[2];
5541 int bincount;
5542} ccv_cnnp_model_unique_consecutive_t;
5543
5544static 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)
5545{
5546 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
5547 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);
5548 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5549 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", 5549, __extension__ __PRETTY_FUNCTION__
); }));
5550 if (self->bincount > 0)
5551 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; }
);
5552 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5553 params.datatype = CCV_32S;
5554 outputs[1] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5555 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");
5556}
5557
5558static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const self, void* const context);
5559
5560static const ccv_cnnp_model_vtab_t ccv_cnnp_unique_consecutive_isa = {
5561 .build = _ccv_cnnp_unique_consecutive_build,
5562 .copy = _ccv_cnnp_unique_consecutive_copy,
5563};
5564
5565ccv_cnnp_model_t* ccv_cnnp_unique_consecutive(const int bincount, const char* const name)
5566{
5567 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));
5568 model_unique_consecutive->super.isa = &ccv_cnnp_unique_consecutive_isa;
5569 model_unique_consecutive->super.input_size = 0;
5570 model_unique_consecutive->super.outputs = model_unique_consecutive->outputs;
5571 model_unique_consecutive->super.output_size = 2;
5572 model_unique_consecutive->bincount = bincount;
5573 ccv_cnnp_model_copy_name(&model_unique_consecutive->super, name);
5574 return (ccv_cnnp_model_t*)model_unique_consecutive;
5575}
5576
5577static ccv_cnnp_model_t* _ccv_cnnp_unique_consecutive_copy(const ccv_cnnp_model_t* const super, void* const context)
5578{
5579 ccv_cnnp_model_unique_consecutive_t* const self = (ccv_cnnp_model_unique_consecutive_t*)super;
5580 return ccv_cnnp_unique_consecutive(self->bincount, self->super.name);
5581}
5582
5583/// MARK - Scatter add layer.
5584
5585typedef struct {
5586 ccv_cnnp_model_t super;
5587 ccv_nnc_tensor_symbol_t output;
5588 int bincount;
5589 int count_per_output;
5590} ccv_cnnp_model_scatter_add_t;
5591
5592static 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)
5593{
5594 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
5595 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);
5596 ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5597 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", 5597, __extension__ __PRETTY_FUNCTION__
); }));
5598 assert(self->bincount >= 0 && (self->bincount > 0 || params.dim[0] == 0))((void) sizeof ((self->bincount >= 0 && (self->
bincount > 0 || params.dim[0] == 0)) ? 1 : 0), __extension__
({ if (self->bincount >= 0 && (self->bincount
> 0 || params.dim[0] == 0)) ; else __assert_fail ("self->bincount >= 0 && (self->bincount > 0 || params.dim[0] == 0)"
, "ccv_cnnp_model_addons.c", 5598, __extension__ __PRETTY_FUNCTION__
); }));
5599 if (params.dim[0] != 0)
5600 params.dim[0] = self->bincount;
5601 outputs[0] = ccv_nnc_tensor_symbol_new(graph, params, 0);
5602 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");
5603}
5604
5605static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const self, void* const context);
5606
5607static const ccv_cnnp_model_vtab_t ccv_cnnp_scatter_add_isa = {
5608 .build = _ccv_cnnp_scatter_add_build,
5609 .copy = _ccv_cnnp_scatter_add_copy,
5610};
5611
5612ccv_cnnp_model_t* ccv_cnnp_scatter_add(const int bincount, const int count_per_output, const char* const name)
5613{
5614 assert(bincount >= 0)((void) sizeof ((bincount >= 0) ? 1 : 0), __extension__ ({
if (bincount >= 0) ; else __assert_fail ("bincount >= 0"
, "ccv_cnnp_model_addons.c", 5614, __extension__ __PRETTY_FUNCTION__
); }));
5615 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", 5615, __extension__ __PRETTY_FUNCTION__
); }));
5616 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));
5617 model_scatter_add->super.isa = &ccv_cnnp_scatter_add_isa;
5618 model_scatter_add->super.input_size = 0;
5619 model_scatter_add->super.outputs = &model_scatter_add->output;
5620 model_scatter_add->super.output_size = 1;
5621 model_scatter_add->bincount = bincount;
5622 model_scatter_add->count_per_output = count_per_output;
5623 ccv_cnnp_model_copy_name(&model_scatter_add->super, name);
5624 return (ccv_cnnp_model_t*)model_scatter_add;
5625}
5626
5627static ccv_cnnp_model_t* _ccv_cnnp_scatter_add_copy(const ccv_cnnp_model_t* const super, void* const context)
5628{
5629 ccv_cnnp_model_scatter_add_t* const self = (ccv_cnnp_model_scatter_add_t*)super;
5630 return ccv_cnnp_scatter_add(self->bincount, self->count_per_output, self->super.name);
5631}
5632
5633// MARK - Segmented Dense Layer
5634
5635typedef struct {
5636 ccv_cnnp_model_t super;
5637 ccv_nnc_tensor_symbol_t output;
5638 ccv_nnc_tensor_symbol_t weights;
5639 ccv_nnc_tensor_symbol_t bias;
5640 int segments;
5641 int count;
5642 int no_bias;
5643 int flags;
5644 int functional;
5645} ccv_cnnp_model_segmented_dense_t;
5646
5647static 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)
5648{
5649 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5650 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);
5651 assert(input_size == (self->functional ? 4 + !self->no_bias : 3))((void) sizeof ((input_size == (self->functional ? 4 + !self
->no_bias : 3)) ? 1 : 0), __extension__ ({ if (input_size ==
(self->functional ? 4 + !self->no_bias : 3)) ; else __assert_fail
("input_size == (self->functional ? 4 + !self->no_bias : 3)"
, "ccv_cnnp_model_addons.c", 5651, __extension__ __PRETTY_FUNCTION__
); }));
5652 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", 5652, __extension__ __PRETTY_FUNCTION__
); }));
5653 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5654 const ccv_nnc_tensor_param_t indices_params = ccv_nnc_tensor_symbol_params(graph, inputs[1]);
5655 const ccv_nnc_tensor_param_t counts_params = ccv_nnc_tensor_symbol_params(graph, inputs[2]);
5656 ccv_nnc_tensor_param_t weights_params;
5657 ccv_nnc_tensor_symbol_t weights;
5658 if (self->functional)
5659 {
5660 weights = inputs[3];
5661 weights_params = ccv_nnc_tensor_symbol_params(graph, weights);
5662 } else {
5663 weights_params = params;
5664 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5665 if (params.dim[0] != 0)
5666 {
5667 weights_params.dim[0] = self->segments;
5668 weights_params.dim[1] = self->count;
5669 weights_params.dim[2] = params.dim[ccv_nnc_tensor_nd(params.dim) - 1];
5670 }
5671 if (!self->weights.graph)
5672 self->weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "weights");
5673 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"
, 5673, __extension__ __PRETTY_FUNCTION__); }));
5674 weights = ccv_cnnp_model_get_symbol(super, self->weights);
5675 }
5676 ccv_nnc_tensor_param_t bias_params = {};
5677 ccv_nnc_tensor_symbol_t bias = {};
5678 if (!self->no_bias)
5679 {
5680 if (self->functional)
5681 {
5682 bias = inputs[4];
5683 bias_params = ccv_nnc_tensor_symbol_params(graph, bias);
5684 } else {
5685 bias_params = params;
5686 memset(bias_params.dim, 0, sizeof(bias_params.dim));
5687 bias_params.dim[0] = self->segments;
5688 bias_params.dim[1] = self->count;
5689 if (!self->bias.graph)
5690 self->bias = ccv_nnc_tensor_symbol_new(graph, bias_params, "bias");
5691 bias = ccv_cnnp_model_get_symbol(super, self->bias);
5692 }
5693 }
5694 ccv_nnc_cmd_t cmd = {0};
5695 cmd.cmd = CCV_NNC_SEGMENTED_GEMM_FORWARD;
5696 cmd.info.blas.a[0] = 1;
5697 cmd.info.blas.a[1] = 1;
5698 cmd.info.blas.transpose_b[0] = 1;
5699 cmd.info.blas.transpose_b[1] = 2;
5700 cmd.info.blas.flags = self->flags;
5701 ccv_nnc_tensor_param_t output_params;
5702 ccv_nnc_hint_tensor_auto(cmd, (ccv_nnc_tensor_param_t []){
5703 params, indices_params, counts_params,
5704 weights_params,
5705 bias_params,
5706 }, 4 + !self->no_bias, ccv_nnc_no_hint, &output_params, 1);
5707 const ccv_nnc_tensor_symbol_t output = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
5708 if (self->no_bias)
5709 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");
5710 else
5711 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");
5712 outputs[0] = output;
5713}
5714
5715static 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)
5716{
5717 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5718 if (self->functional)
5719 return;
5720 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->weights);
5721 const int c = weight_params.dim[1];
5722 const float std = sqrtf(2) / sqrtf(c);
5723 const float bound = sqrtf(3) * std;
5724 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);
5725 if (self->bias.graph)
5726 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);
5727}
5728
5729static 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)
5730{
5731 ccv_cnnp_model_segmented_dense_t* const self = (ccv_cnnp_model_segmented_dense_t*)super;
5732 if (self->functional)
5733 return;
5734 add_to_array(parameters, self->weights, is_trainable);
5735 if (self->bias.graph)
5736 add_to_array(parameters, self->bias, is_trainable);
5737}
5738
5739static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context);
5740
5741static const ccv_cnnp_model_vtab_t ccv_cnnp_segmented_dense_isa = {
5742 .build = _ccv_cnnp_segmented_dense_build,
5743 .init_states = _ccv_cnnp_segmented_dense_init_states,
5744 .add_to_parameter = _ccv_cnnp_segmented_dense_add_to_parameter,
5745 .copy = _ccv_cnnp_segmented_dense_copy,
5746};
5747
5748ccv_cnnp_model_t* ccv_cnnp_segmented_dense(const int segments, const int count, const int no_bias, const int flags, const int functional, const int is_trainable, const char* const name)
5749{
5750 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));
5751 model_segmented_dense->super.isa = &ccv_cnnp_segmented_dense_isa;
5752 model_segmented_dense->super.input_size = functional ? 4 + !no_bias : 3;
5753 model_segmented_dense->super.outputs = &model_segmented_dense->output;
5754 model_segmented_dense->super.output_size = 1;
5755 model_segmented_dense->super.is_trainable = is_trainable;
5756 ccv_cnnp_model_copy_name(&model_segmented_dense->super, name);
5757 model_segmented_dense->weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5758 model_segmented_dense->weights.graph = 0;
5759 model_segmented_dense->bias.d = CCV_NNC_NO_TENSOR_SYMBOL;
5760 model_segmented_dense->bias.graph = 0;
5761 model_segmented_dense->segments = segments;
5762 model_segmented_dense->count = count;
5763 model_segmented_dense->no_bias = no_bias;
5764 model_segmented_dense->flags = flags;
5765 model_segmented_dense->functional = functional;
5766 return (ccv_cnnp_model_t*)model_segmented_dense;
5767}
5768
5769static ccv_cnnp_model_t* _ccv_cnnp_segmented_dense_copy(const ccv_cnnp_model_t* const super, void* const context)
5770{
5771 const ccv_cnnp_model_segmented_dense_t* const self = (const ccv_cnnp_model_segmented_dense_t*)super;
5772 return ccv_cnnp_segmented_dense(self->segments, self->count, self->no_bias, self->flags, self->functional, self->super.is_trainable, self->super.name);
5773}
5774
5775// MARK - SwiGLU Layer
5776
5777typedef struct {
5778 ccv_cnnp_model_t super;
5779 ccv_nnc_tensor_symbol_t output;
5780 ccv_nnc_tensor_symbol_t gate_weights;
5781 ccv_nnc_tensor_symbol_t up_weights;
5782 int count;
5783 float clamp;
5784} ccv_cnnp_model_swiglu_t;
5785
5786static void _ccv_cnnp_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)
5787{
5788 ccv_cnnp_model_swiglu_t* const self = (ccv_cnnp_model_swiglu_t*)super;
5789 PRINT(CCV_CLI_VERBOSE, "[cnnp_swiglu_build] -\n")do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_swiglu_build] -\n"); fflush(stdout); } } while
(0);
5790 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"
, 5790, __extension__ __PRETTY_FUNCTION__); }));
5791 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", 5791, __extension__ __PRETTY_FUNCTION__
); }));
5792 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5793 const int params_nd = ccv_nnc_tensor_nd(params.dim);
5794 ccv_nnc_tensor_param_t weights_params = params;
5795 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5796 if (params_nd > 0)
5797 {
5798 weights_params.dim[0] = self->count;
5799 weights_params.dim[1] = params.dim[params_nd - 1];
5800 }
5801 if (!self->gate_weights.graph)
5802 self->gate_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "gate.weight");
5803 if (!self->up_weights.graph)
5804 self->up_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "up.weight");
5805 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", 5805, __extension__ __PRETTY_FUNCTION__
); }));
5806 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"
, 5806, __extension__ __PRETTY_FUNCTION__); }));
5807 const ccv_nnc_tensor_symbol_t gate_weights = ccv_cnnp_model_get_symbol(super, self->gate_weights);
5808 const ccv_nnc_tensor_symbol_t up_weights = ccv_cnnp_model_get_symbol(super, self->up_weights);
5809 const ccv_nnc_cmd_t cmd = CMD_SWIGLU_FORWARD(self->clamp)ccv_nnc_cmd(CCV_NNC_SWIGLU_FORWARD, 0, ((ccv_nnc_cmd_param_t)
{.size={.dim={1,1,1}},.swiglu={.clamp=self->clamp}}), 0);
5810 const ccv_nnc_tensor_symbol_t command_inputs[] = {
5811 inputs[0], gate_weights, up_weights,
5812 };
5813 ccv_nnc_tensor_param_t command_input_params[3];
5814 int i;
5815 for (i = 0; i < 3; i++)
5816 command_input_params[i] = ccv_nnc_tensor_symbol_params(graph, command_inputs[i]);
5817 ccv_nnc_tensor_param_t output_params;
5818 ccv_nnc_hint_tensor_auto(cmd, command_input_params, 3, ccv_nnc_no_hint, &output_params, 1);
5819 outputs[0] = ccv_nnc_tensor_symbol_new(graph, output_params, 0);
5820 ccv_nnc_graph_exec_symbol_new(graph, cmd, command_inputs, 3, outputs, 1, "swiglu");
5821}
5822
5823static void _ccv_cnnp_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)
5824{
5825 ccv_cnnp_model_swiglu_t* const self = (ccv_cnnp_model_swiglu_t*)super;
5826 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->gate_weights);
5827 const float bound = sqrtf(6.f / weight_params.dim[1]);
5828 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);
5829 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);
5830}
5831
5832static void _ccv_cnnp_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)
5833{
5834 ccv_cnnp_model_swiglu_t* const self = (ccv_cnnp_model_swiglu_t*)super;
5835 add_to_array(parameters, self->gate_weights, is_trainable);
5836 add_to_array(parameters, self->up_weights, is_trainable);
5837}
5838
5839static ccv_cnnp_model_t* _ccv_cnnp_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context);
5840
5841static const ccv_cnnp_model_vtab_t ccv_cnnp_swiglu_isa = {
5842 .build = _ccv_cnnp_swiglu_build,
5843 .init_states = _ccv_cnnp_swiglu_init_states,
5844 .add_to_parameter = _ccv_cnnp_swiglu_add_to_parameter,
5845 .copy = _ccv_cnnp_swiglu_copy,
5846};
5847
5848ccv_cnnp_model_t* ccv_cnnp_swiglu(const int count, const float clamp, const int is_trainable, const char* const name)
5849{
5850 ccv_cnnp_model_swiglu_t* const model = (ccv_cnnp_model_swiglu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_swiglu_t));
5851 model->super.isa = &ccv_cnnp_swiglu_isa;
5852 model->super.input_size = 1;
5853 model->super.outputs = &model->output;
5854 model->super.output_size = 1;
5855 model->super.is_trainable = is_trainable;
5856 ccv_cnnp_model_copy_name(&model->super, name);
5857 model->gate_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5858 model->up_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
5859 model->count = count;
5860 model->clamp = clamp;
5861 return (ccv_cnnp_model_t*)model;
5862}
5863
5864static ccv_cnnp_model_t* _ccv_cnnp_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context)
5865{
5866 const ccv_cnnp_model_swiglu_t* const self = (const ccv_cnnp_model_swiglu_t*)super;
5867 return ccv_cnnp_swiglu(self->count, self->clamp, self->super.is_trainable, self->super.name);
5868}
5869
5870// MARK - Segmented SwiGLU Layer
5871
5872typedef struct {
5873 ccv_cnnp_model_t super;
5874 ccv_nnc_tensor_symbol_t outputs[2]; // The routed SwiGLU, and the shared expert's SwiGLU.
5875 ccv_nnc_tensor_symbol_t gate_weights;
5876 ccv_nnc_tensor_symbol_t up_weights;
5877 ccv_nnc_tensor_symbol_t shared_gate_weights;
5878 ccv_nnc_tensor_symbol_t shared_up_weights;
5879 int segments;
5880 int count;
5881 float clamp;
5882 int functional;
5883 int shared_expert;
5884} ccv_cnnp_model_segmented_swiglu_t;
5885
5886static 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)
5887{
5888 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5889 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);
5890 assert(input_size == (self->functional ? (self->shared_expert ? 9 : 6) : (self->shared_expert ? 5 : 4)))((void) sizeof ((input_size == (self->functional ? (self->
shared_expert ? 9 : 6) : (self->shared_expert ? 5 : 4))) ?
1 : 0), __extension__ ({ if (input_size == (self->functional
? (self->shared_expert ? 9 : 6) : (self->shared_expert
? 5 : 4))) ; else __assert_fail ("input_size == (self->functional ? (self->shared_expert ? 9 : 6) : (self->shared_expert ? 5 : 4))"
, "ccv_cnnp_model_addons.c", 5890, __extension__ __PRETTY_FUNCTION__
); }));
5891 assert(output_size == (self->shared_expert ? 2 : 1))((void) sizeof ((output_size == (self->shared_expert ? 2 :
1)) ? 1 : 0), __extension__ ({ if (output_size == (self->
shared_expert ? 2 : 1)) ; else __assert_fail ("output_size == (self->shared_expert ? 2 : 1)"
, "ccv_cnnp_model_addons.c", 5891, __extension__ __PRETTY_FUNCTION__
); }));
5892 const ccv_nnc_tensor_param_t params = ccv_nnc_tensor_symbol_params(graph, inputs[0]);
5893 ccv_nnc_tensor_symbol_t gate_weights;
5894 ccv_nnc_tensor_symbol_t up_weights;
5895 ccv_nnc_tensor_symbol_t shared_gate_weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5896 ccv_nnc_tensor_symbol_t shared_up_weights = NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
};
5897 if (self->functional)
5898 {
5899 gate_weights = inputs[3];
5900 up_weights = inputs[4];
5901 if (self->shared_expert)
5902 {
5903 shared_gate_weights = inputs[7];
5904 shared_up_weights = inputs[8];
5905 }
5906 } else {
5907 const int params_nd = ccv_nnc_tensor_nd(params.dim);
5908 ccv_nnc_tensor_param_t weights_params = params;
5909 memset(weights_params.dim, 0, sizeof(weights_params.dim));
5910 if (params_nd > 0)
5911 {
5912 weights_params.dim[0] = self->segments;
5913 weights_params.dim[1] = self->count;
5914 weights_params.dim[2] = params.dim[params_nd - 1];
5915 }
5916 if (!self->gate_weights.graph)
5917 self->gate_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "gate.weight");
5918 if (!self->up_weights.graph)
5919 self->up_weights = ccv_nnc_tensor_symbol_new(graph, weights_params, "up.weight");
5920 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", 5920, __extension__ __PRETTY_FUNCTION__
); }));
5921 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"
, 5921, __extension__ __PRETTY_FUNCTION__); }));
5922 gate_weights = ccv_cnnp_model_get_symbol(super, self->gate_weights);
5923 up_weights = ccv_cnnp_model_get_symbol(super, self->up_weights);
5924 if (self->shared_expert)
5925 {
5926 // The shared expert is as wide as each routed expert, over its own activation's width.
5927 const ccv_nnc_tensor_param_t shared_params = ccv_nnc_tensor_symbol_params(graph, inputs[4]);
5928 const int shared_params_nd = ccv_nnc_tensor_nd(shared_params.dim);
5929 ccv_nnc_tensor_param_t shared_weights_params = shared_params;
5930 memset(shared_weights_params.dim, 0, sizeof(shared_weights_params.dim));
5931 if (shared_params_nd > 0)
5932 {
5933 shared_weights_params.dim[0] = self->count;
5934 shared_weights_params.dim[1] = shared_params.dim[shared_params_nd - 1];
5935 }
5936 if (!self->shared_gate_weights.graph)
5937 self->shared_gate_weights = ccv_nnc_tensor_symbol_new(graph, shared_weights_params, "shared_gate.weight");
5938 if (!self->shared_up_weights.graph)
5939 self->shared_up_weights = ccv_nnc_tensor_symbol_new(graph, shared_weights_params, "shared_up.weight");
5940 assert(self->shared_gate_weights.graph == graph)((void) sizeof ((self->shared_gate_weights.graph == graph)
? 1 : 0), __extension__ ({ if (self->shared_gate_weights.
graph == graph) ; else __assert_fail ("self->shared_gate_weights.graph == graph"
, "ccv_cnnp_model_addons.c", 5940, __extension__ __PRETTY_FUNCTION__
); }));
5941 assert(self->shared_up_weights.graph == graph)((void) sizeof ((self->shared_up_weights.graph == graph) ?
1 : 0), __extension__ ({ if (self->shared_up_weights.graph
== graph) ; else __assert_fail ("self->shared_up_weights.graph == graph"
, "ccv_cnnp_model_addons.c", 5941, __extension__ __PRETTY_FUNCTION__
); }));
5942 shared_gate_weights = ccv_cnnp_model_get_symbol(super, self->shared_gate_weights);
5943 shared_up_weights = ccv_cnnp_model_get_symbol(super, self->shared_up_weights);
5944 }
5945 }
5946 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);
5947 const ccv_nnc_tensor_symbol_t command_inputs[] = {
5948 inputs[0], inputs[1], inputs[2], gate_weights, up_weights, inputs[self->functional ? 5 : 3],
5949 self->shared_expert ? inputs[self->functional ? 6 : 4] : NO_TENSOR_SYMBOL(const ccv_nnc_tensor_symbol_t){.d = CCV_NNC_NO_TENSOR_SYMBOL
}, shared_gate_weights, shared_up_weights,
5950 };
5951 const int command_input_size = self->shared_expert ? 9 : 6;
5952 ccv_nnc_tensor_param_t command_input_params[9];
5953 int i;
5954 for (i = 0; i < command_input_size; i++)
5955 command_input_params[i] = ccv_nnc_tensor_symbol_params(graph, command_inputs[i]);
5956 ccv_nnc_tensor_param_t output_params[2];
5957 ccv_nnc_hint_tensor_auto(cmd, command_input_params, command_input_size, ccv_nnc_no_hint, output_params, output_size);
5958 for (i = 0; i < output_size; i++)
5959 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
5960 ccv_nnc_graph_exec_symbol_new(graph, cmd, command_inputs, command_input_size, outputs, output_size, "segmented_swiglu");
5961}
5962
5963static 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)
5964{
5965 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5966 if (self->functional)
5967 return;
5968 const ccv_nnc_tensor_param_t weight_params = ccv_nnc_tensor_symbol_params(graph, self->gate_weights);
5969 const float bound = sqrtf(6.f / weight_params.dim[2]);
5970 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);
5971 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);
5972 if (!self->shared_expert)
5973 return;
5974 const ccv_nnc_tensor_param_t shared_weight_params = ccv_nnc_tensor_symbol_params(graph, self->shared_gate_weights);
5975 const float shared_bound = sqrtf(6.f / shared_weight_params.dim[1]);
5976 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-shared_bound, shared_bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-shared_bound, shared_bound
}}}, 0), ccv_nnc_no_hint, 0, 0, self->shared_gate_weights);
5977 initializer(context, CMD_RANDOM_UNIFORM_FORWARD(-shared_bound, shared_bound)ccv_nnc_cmd(CCV_NNC_RANDOM_UNIFORM_FORWARD, 0, (ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.blas={.a={-shared_bound, shared_bound
}}}, 0), ccv_nnc_no_hint, 0, 0, self->shared_up_weights);
5978}
5979
5980static 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)
5981{
5982 ccv_cnnp_model_segmented_swiglu_t* const self = (ccv_cnnp_model_segmented_swiglu_t*)super;
5983 if (self->functional)
5984 return;
5985 add_to_array(parameters, self->gate_weights, is_trainable);
5986 add_to_array(parameters, self->up_weights, is_trainable);
5987 if (self->shared_expert)
5988 {
5989 add_to_array(parameters, self->shared_gate_weights, is_trainable);
5990 add_to_array(parameters, self->shared_up_weights, is_trainable);
5991 }
5992}
5993
5994static ccv_cnnp_model_t* _ccv_cnnp_segmented_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context);
5995
5996static const ccv_cnnp_model_vtab_t ccv_cnnp_segmented_swiglu_isa = {
5997 .build = _ccv_cnnp_segmented_swiglu_build,
5998 .init_states = _ccv_cnnp_segmented_swiglu_init_states,
5999 .add_to_parameter = _ccv_cnnp_segmented_swiglu_add_to_parameter,
6000 .copy = _ccv_cnnp_segmented_swiglu_copy,
6001};
6002
6003ccv_cnnp_model_t* ccv_cnnp_segmented_swiglu(const int segments, const int count, const float clamp, const int functional, const int shared_expert, const int is_trainable, const char* const name)
6004{
6005 ccv_cnnp_model_segmented_swiglu_t* const model = (ccv_cnnp_model_segmented_swiglu_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_segmented_swiglu_t));
6006 model->super.isa = &ccv_cnnp_segmented_swiglu_isa;
6007 model->super.input_size = functional ? (shared_expert ? 9 : 6) : (shared_expert ? 5 : 4);
6008 model->super.outputs = model->outputs;
6009 model->super.output_size = shared_expert ? 2 : 1;
6010 model->super.is_trainable = is_trainable;
6011 ccv_cnnp_model_copy_name(&model->super, name);
6012 model->gate_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
6013 model->up_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
6014 model->shared_gate_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
6015 model->shared_up_weights.d = CCV_NNC_NO_TENSOR_SYMBOL;
6016 model->segments = segments;
6017 model->count = count;
6018 model->clamp = clamp;
6019 model->functional = functional;
6020 model->shared_expert = shared_expert;
6021 return (ccv_cnnp_model_t*)model;
6022}
6023
6024static ccv_cnnp_model_t* _ccv_cnnp_segmented_swiglu_copy(const ccv_cnnp_model_t* const super, void* const context)
6025{
6026 const ccv_cnnp_model_segmented_swiglu_t* const self = (const ccv_cnnp_model_segmented_swiglu_t*)super;
6027 return ccv_cnnp_segmented_swiglu(self->segments, self->count, self->clamp, self->functional, self->shared_expert, self->super.is_trainable, self->super.name);
6028}
6029
6030// MARK - MoE Weights Streaming
6031
6032typedef struct {
6033 ccv_cnnp_model_t super;
6034 ccv_nnc_tensor_symbol_t outputs[6];
6035 int resident_slots;
6036 int routing_width;
6037} ccv_cnnp_model_moe_weights_streaming_t;
6038
6039static void _ccv_cnnp_moe_weights_streaming_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)
6040{
6041 ccv_cnnp_model_moe_weights_streaming_t* const self = (ccv_cnnp_model_moe_weights_streaming_t*)super;
6042 PRINT(CCV_CLI_VERBOSE, "[cnnp_moe_weights_streaming_build] - resident_slots: %d, routing_width: %d\n", self->resident_slots, self->routing_width)do { if ((CCV_CLI_VERBOSE & ccv_cli_get_output_levels()))
{ printf("[cnnp_moe_weights_streaming_build] - resident_slots: %d, routing_width: %d\n"
, self->resident_slots, self->routing_width); fflush(stdout
); } } while (0);
6043 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"
, 6043, __extension__ __PRETTY_FUNCTION__); }));
6044 assert(output_size == 6)((void) sizeof ((output_size == 6) ? 1 : 0), __extension__ ({
if (output_size == 6) ; else __assert_fail ("output_size == 6"
, "ccv_cnnp_model_addons.c", 6044, __extension__ __PRETTY_FUNCTION__
); }));
6045 const ccv_nnc_cmd_t cmd = CMD_MOE_WEIGHTS_STREAMING_FORWARD(self->resident_slots, self->routing_width)ccv_nnc_cmd(CCV_NNC_MOE_WEIGHTS_STREAMING_FORWARD, 0, ((ccv_nnc_cmd_param_t
){.size={.dim={1,1,1}},.moe_weights_streaming={.resident_slots
=(self->resident_slots),.routing_width=(self->routing_width
)}}), 0);
6046 ccv_nnc_tensor_param_t input_params[6];
6047 ccv_nnc_tensor_param_t output_params[6];
6048 int i;
6049 for (i = 0; i < 6; i++)
6050 input_params[i] = ccv_nnc_tensor_symbol_params(graph, inputs[i]);
6051 ccv_nnc_hint_tensor_auto(cmd, input_params, 6, ccv_nnc_no_hint, output_params, 6);
6052 for (i = 0; i < 6; i++)
6053 outputs[i] = ccv_nnc_tensor_symbol_new(graph, output_params[i], 0);
6054 ccv_nnc_graph_exec_symbol_new(graph, cmd, inputs, 6, outputs, 6, "moe_weights_streaming");
6055}
6056
6057static ccv_cnnp_model_t* _ccv_cnnp_moe_weights_streaming_copy(const ccv_cnnp_model_t* const super, void* const context);
6058
6059static const ccv_cnnp_model_vtab_t ccv_cnnp_moe_weights_streaming_isa = {
6060 .build = _ccv_cnnp_moe_weights_streaming_build,
6061 .copy = _ccv_cnnp_moe_weights_streaming_copy,
6062};
6063
6064ccv_cnnp_model_t* ccv_cnnp_moe_weights_streaming(const int resident_slots, const int routing_width, const char* const name)
6065{
6066 assert(resident_slots > 0)((void) sizeof ((resident_slots > 0) ? 1 : 0), __extension__
({ if (resident_slots > 0) ; else __assert_fail ("resident_slots > 0"
, "ccv_cnnp_model_addons.c", 6066, __extension__ __PRETTY_FUNCTION__
); }));
6067 assert(routing_width > 0)((void) sizeof ((routing_width > 0) ? 1 : 0), __extension__
({ if (routing_width > 0) ; else __assert_fail ("routing_width > 0"
, "ccv_cnnp_model_addons.c", 6067, __extension__ __PRETTY_FUNCTION__
); }));
6068 ccv_cnnp_model_moe_weights_streaming_t* const model = (ccv_cnnp_model_moe_weights_streaming_t*)cccalloccalloc(1, sizeof(ccv_cnnp_model_moe_weights_streaming_t));
6069 model->super.isa = &ccv_cnnp_moe_weights_streaming_isa;
6070 model->super.input_size = 6;
6071 model->super.outputs = model->outputs;
6072 model->super.output_size = 6;
6073 model->resident_slots = resident_slots;
6074 model->routing_width = routing_width;
6075 ccv_cnnp_model_copy_name(&model->super, name);
6076 return (ccv_cnnp_model_t*)model;
6077}
6078
6079static ccv_cnnp_model_t* _ccv_cnnp_moe_weights_streaming_copy(const ccv_cnnp_model_t* const super, void* const context)
6080{
6081 const ccv_cnnp_model_moe_weights_streaming_t* const self = (const ccv_cnnp_model_moe_weights_streaming_t*)super;
6082 return ccv_cnnp_moe_weights_streaming(self->resident_slots, self->routing_width, self->super.name);
6083}