Coverage Report

Created: 2025-02-24 17:43

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