Bug Summary

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