operators.hpp 25.2 KB
Newer Older
Paul's avatar
Paul committed
1
2
#ifndef MIGRAPH_GUARD_OPERATORS_HPP
#define MIGRAPH_GUARD_OPERATORS_HPP
Paul's avatar
Paul committed
3

4
#include <array>
Paul's avatar
Paul committed
5
#include <migraph/operation.hpp>
Paul's avatar
Paul committed
6
#include <migraph/check_shapes.hpp>
Paul's avatar
Paul committed
7
8
#include <migraph/stringutils.hpp>
#include <migraph/streamutils.hpp>
Paul's avatar
Paul committed
9
#include <cmath>
Paul's avatar
Paul committed
10
#include <utility>
Paul's avatar
Paul committed
11

Paul's avatar
Paul committed
12
namespace migraph {
13
namespace op {
Paul's avatar
Paul committed
14

Paul's avatar
Paul committed
15
16
struct not_computable
{
Paul's avatar
Paul committed
17
    argument compute(context&, const shape&, const std::vector<argument>&) const
Paul's avatar
Paul committed
18
19
20
    {
        MIGRAPH_THROW("not computable");
    }
Paul's avatar
Paul committed
21
22
};

23
24
struct batch_norm_inference
{
25
26
    float epsilon  = 1.0e-6f;
    float momentum = 0.9f;
27
28
29

    std::string name() const { return "batch_norm_inference"; }

30
31
32
33
34
35
36
37
    enum bn_infer_mode_t
    {
        per_activation,
        spatial,
    };

    bn_infer_mode_t bn_mode = spatial;

Paul's avatar
Paul committed
38
39
40
41
    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
        return pack(
Paul's avatar
Paul committed
42
            f(self.epsilon, "epsilon"), f(self.momentum, "momentum"), f(self.bn_mode, "bn_mode"));
Paul's avatar
Paul committed
43
    }
44

45
46
47
48
49
50
51
    shape compute_shape(std::vector<shape> inputs) const
    {
        check_shapes{inputs, *this}.has(5);
        return inputs.front();
    }
};

Paul's avatar
Paul committed
52
struct convolution
Paul's avatar
Paul committed
53
{
Paul's avatar
Paul committed
54
55
56
    std::array<std::size_t, 2> padding  = {{0, 0}};
    std::array<std::size_t, 2> stride   = {{1, 1}};
    std::array<std::size_t, 2> dilation = {{1, 1}};
Paul's avatar
Paul committed
57
58
59
60
61
62
63
    enum padding_mode_t
    {
        default_, // NOLINT
        same,
        valid
    };
    padding_mode_t padding_mode = default_;
Paul's avatar
Paul committed
64
65
66
67

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
68
69
70
71
        return pack(f(self.padding, "padding"),
                    f(self.stride, "stride"),
                    f(self.dilation, "dilation"),
                    f(self.padding_mode, "padding_mode"));
Paul's avatar
Paul committed
72
73
    }

Paul's avatar
Paul committed
74
    std::string name() const { return "convolution"; }
Paul's avatar
Paul committed
75
76
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
77
        check_shapes{inputs, *this}.has(2).same_type().same_ndims().only_dims(4);
Paul's avatar
Paul committed
78

Paul's avatar
Paul committed
79
        const shape& input   = inputs.at(0);
Paul's avatar
Paul committed
80
        const shape& weights = inputs.at(1);
Paul's avatar
Paul committed
81
        auto t               = input.type();
Paul's avatar
Paul committed
82
83
        if(padding_mode == default_)
        {
Paul's avatar
Paul committed
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
            return {t,
                    {
                        input.lens()[0],
                        weights.lens()[0],
                        std::size_t(std::max<std::ptrdiff_t>(
                            1,
                            (input.lens()[2] - (1 + dilation[0] * (weights.lens()[2] - 1)) +
                             2 * padding[0]) /
                                    stride[0] +
                                1)),
                        std::size_t(std::max<std::ptrdiff_t>(
                            1,
                            (input.lens()[3] - (1 + dilation[1] * (weights.lens()[3] - 1)) +
                             2 * padding[1]) /
                                    stride[1] +
                                1)),
                    }};
Paul's avatar
Paul committed
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
        }
        else if(padding_mode == same)
        {
            return {t,
                    {input.lens()[0],
                     weights.lens()[0],
                     static_cast<std::size_t>(
                         std::ceil(static_cast<double>(input.lens()[2]) / stride[0])),
                     static_cast<std::size_t>(
                         std::ceil(static_cast<double>(input.lens()[3]) / stride[1]))}};
        }
        else if(padding_mode == valid)
        {
            return {
                t,
                {input.lens()[0],
                 weights.lens()[0],
                 static_cast<std::size_t>(std::ceil(
                     static_cast<double>(input.lens()[2] - weights.lens()[2] + 1) / stride[0])),
                 static_cast<std::size_t>(std::ceil(
                     static_cast<double>(input.lens()[3] - weights.lens()[3] + 1) / stride[1]))}};
        }
        else
        {
Paul's avatar
Paul committed
125
            MIGRAPH_THROW("Invalid padding mode");
Paul's avatar
Paul committed
126
        }
Paul's avatar
Paul committed
127
128
129
    }
};

Scott Thornton's avatar
Scott Thornton committed
130
131
struct im2col
{
Scott Thornton's avatar
Scott Thornton committed
132
133
134
135
136
137
138
139
140
    std::array<std::size_t, 2> padding  = {{0, 0}};
    std::array<std::size_t, 2> stride   = {{1, 1}};
    std::array<std::size_t, 2> dilation = {{1, 1}};
    enum padding_mode_t
    {
        default_, // NOLINT
        same,
        valid
    };
Paul's avatar
Paul committed
141
142
143
144
145
    padding_mode_t padding_mode = default_;

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
146
147
148
149
        return pack(f(self.padding, "padding"),
                    f(self.stride, "stride"),
                    f(self.dilation, "dilation"),
                    f(self.padding_mode, "padding_mode"));
Paul's avatar
Paul committed
150
    }
Scott Thornton's avatar
Scott Thornton committed
151
152
153
154
155

    std::string name() const { return "im2col"; }

    shape compute_shape(std::vector<shape> inputs) const
    {
Scott Thornton's avatar
Scott Thornton committed
156
157
158
        auto input          = inputs[0];
        auto weights        = inputs[1];
        auto batch_size     = input.lens()[0];
Scott Thornton's avatar
Scott Thornton committed
159
        auto input_channels = weights.lens()[1];
Scott Thornton's avatar
Scott Thornton committed
160
161
        auto kernel_height  = weights.lens()[2];
        auto kernel_width   = weights.lens()[3];
Scott Thornton's avatar
Scott Thornton committed
162
        check_shapes{inputs, *this}.has(2);
Scott Thornton's avatar
Scott Thornton committed
163
164
        if(batch_size != 1)
            MIGRAPH_THROW("im2col only support batch_size 1");
Scott Thornton's avatar
Scott Thornton committed
165
        auto output_height = std::size_t(std::max<std::ptrdiff_t>(
Scott Thornton's avatar
Scott Thornton committed
166
167
168
            1,
            (input.lens()[2] - (1 + dilation[0] * (kernel_height - 1)) + 2 * padding[0]) /
                    stride[0] +
Scott Thornton's avatar
Scott Thornton committed
169
                1));
Scott Thornton's avatar
Scott Thornton committed
170
171
172
173
        auto output_width  = std::size_t(std::max<std::ptrdiff_t>(
            1,
            (input.lens()[3] - (1 + dilation[1] * (kernel_width - 1)) + 2 * padding[1]) /
                    stride[1] +
Scott Thornton's avatar
Scott Thornton committed
174
                1));
Scott Thornton's avatar
Scott Thornton committed
175
176
        auto channels_col  = kernel_height * kernel_width * input_channels;
        return {input.type(), {output_height * output_width, channels_col}};
Scott Thornton's avatar
Scott Thornton committed
177
178
179
    }
};

Paul's avatar
Paul committed
180
struct pooling
Paul's avatar
Paul committed
181
{
Paul's avatar
Paul committed
182
    std::string mode                   = "average";
Paul's avatar
Paul committed
183
184
185
    std::array<std::size_t, 2> padding = {{0, 0}};
    std::array<std::size_t, 2> stride  = {{1, 1}};
    std::array<std::size_t, 2> lengths = {{1, 1}};
Paul's avatar
Paul committed
186
187
188
189

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
190
191
192
193
        return pack(f(self.mode, "mode"),
                    f(self.padding, "padding"),
                    f(self.stride, "stride"),
                    f(self.lengths, "lengths"));
Paul's avatar
Paul committed
194
195
    }

Paul's avatar
Paul committed
196
    std::string name() const { return "pooling"; }
Scott Thornton's avatar
Scott Thornton committed
197

Paul's avatar
Paul committed
198
199
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
200
        check_shapes{inputs, *this}.has(1).only_dims(4);
Paul's avatar
Paul committed
201

Paul's avatar
Paul committed
202
        const shape& input = inputs.at(0);
Paul's avatar
Paul committed
203
        auto t             = input.type();
Paul's avatar
Paul committed
204

Paul's avatar
Paul committed
205
206
        assert(lengths[0] <= (input.lens()[2] + 2 * padding[0]));
        assert(lengths[1] <= (input.lens()[3] + 2 * padding[1]));
Paul's avatar
Paul committed
207

Scott Thornton's avatar
Scott Thornton committed
208
209
210
211
212
213
        return {t,
                {
                    input.lens()[0],
                    input.lens()[1],
                    std::size_t(std::max<std::ptrdiff_t>(
                        1,
Paul's avatar
Paul committed
214
                        std::ptrdiff_t(std::floor((input.lens()[2] + 2 * padding[0] - lengths[0]) /
Paul's avatar
Paul committed
215
                                                  static_cast<float>(stride[0]))) +
Scott Thornton's avatar
Scott Thornton committed
216
217
218
                            1)),
                    std::size_t(std::max<std::ptrdiff_t>(
                        1,
Paul's avatar
Paul committed
219
                        std::ptrdiff_t(std::floor((input.lens()[3] + 2 * padding[1] - lengths[1]) /
Paul's avatar
Paul committed
220
                                                  static_cast<float>(stride[1]))) +
Scott Thornton's avatar
Scott Thornton committed
221
222
                            1)),
                }};
Paul's avatar
Paul committed
223
224
225
    }
};

Paul's avatar
Paul committed
226
struct activation
Paul's avatar
Paul committed
227
228
{
    std::string mode;
Paul's avatar
Paul committed
229
    std::string name() const { return "activation"; }
Paul's avatar
Paul committed
230
231
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
232
        check_shapes{inputs, *this}.has(1);
Paul's avatar
Paul committed
233
234
        return inputs.front();
    }
Paul's avatar
Paul committed
235
    friend std::ostream& operator<<(std::ostream& os, const activation& op)
Paul's avatar
Paul committed
236
    {
Paul's avatar
Paul committed
237
        os << op.name() << ":" << op.mode;
Paul's avatar
Paul committed
238
239
        return os;
    }
Paul's avatar
Paul committed
240
241
};

Khalique's avatar
Khalique committed
242
243
244
245
246
247
248
249
250
251
252
253
254
struct leaky_relu
{
    std::string name() const { return "leaky_relu"; }
    float alpha;
    shape compute_shape(std::vector<shape> inputs) const
    {
        check_shapes{inputs, *this}.has(1);
        return inputs.front();
    }
    friend std::ostream& operator<<(std::ostream& os, const leaky_relu& op)
    {
        os << op.name() << ":" << op.alpha;
        return os;
Khalique's avatar
Khalique committed
255
    }
Khalique's avatar
Khalique committed
256
257
};

258
259
260
struct transpose
{
    std::vector<int64_t> dims;
Paul's avatar
Paul committed
261
262
263
264

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
265
        return pack(f(self.dims, "dims"));
Paul's avatar
Paul committed
266
267
    }

268
269
270
    std::string name() const { return "transpose"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
271
        check_shapes{inputs, *this}.has(1);
272
        auto input         = inputs.at(0);
273
        auto input_lens    = input.lens();
274
275
        auto input_strides = input.strides();
        auto t             = input.type();
Paul's avatar
Paul committed
276
277
        if(dims.size() != input_lens.size())
        {
Paul's avatar
Paul committed
278
            MIGRAPH_THROW("Permutation has wrong number of axes");
279
280
281
        }
        std::vector<int64_t> axes(dims.size());
        std::iota(axes.begin(), axes.end(), 0);
Paul's avatar
Paul committed
282
283
        if(!std::is_permutation(axes.begin(), axes.end(), dims.begin()))
        {
Paul's avatar
Paul committed
284
            MIGRAPH_THROW("Invalid permutation");
285
        }
286
287
        std::vector<size_t> output_lens(input_lens.size());
        std::vector<size_t> output_strides(input_lens.size());
Paul's avatar
Paul committed
288
289
290
        for(int i = 0; i < output_lens.size(); i++)
        {
            output_lens[i]    = input_lens[dims[i]];
291
292
            output_strides[i] = input_strides[dims[i]];
        }
293
        return {t, output_lens, output_strides};
294
    }
Paul's avatar
Paul committed
295
    argument compute(context&, shape output_shape, std::vector<argument> args) const
Paul's avatar
Paul committed
296
    {
Paul's avatar
Paul committed
297
        return {std::move(output_shape), std::move(args.front().data)};
Paul's avatar
Paul committed
298
    }
Paul's avatar
Paul committed
299
300
301
302
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
303
304
};

Paul's avatar
Paul committed
305
struct contiguous
306
307
308
309
{
    std::string name() const { return "contiguous"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
310
        check_shapes{inputs, *this}.has(1);
Paul's avatar
Paul committed
311
312
        auto lens = inputs.at(0).lens();
        auto t    = inputs.at(0).type();
313
314
315
316
        return {t, lens};
    }
};

317
318
319
320
struct concat
{
    std::size_t axis = 0;
    std::string name() const { return "concat"; }
321
322
323
324
325
326
327
328
329
330
331
332
333
    std::vector<std::size_t> compute_offsets(const shape& output_shape,
                                             const std::vector<argument> args) const
    {
        std::vector<std::size_t> offsets;
        std::vector<std::size_t> offset(args[0].get_shape().lens().size(), 0);
        offset[axis] = 0;
        for(const auto& arg : args)
        {
            offsets.push_back(output_shape.index(offset));
            offset[axis] += arg.get_shape().lens()[axis];
        }
        return offsets;
    }
334
335
    shape compute_shape(std::vector<shape> inputs) const
    {
Scott Thornton's avatar
Scott Thornton committed
336
        if(inputs.empty())
337
338
339
340
341
        {
            MIGRAPH_THROW("Number of input tensors should exceed 0");
        }

        const auto& first_shape_lens = inputs.front().lens();
Scott Thornton's avatar
Scott Thornton committed
342
343
344
345
346
347
348
349
350
351
        const auto& type             = inputs.front().type();
        for(std::size_t l = 0; l < first_shape_lens.size(); l++)
        {
            if(l != axis)
            {
                if(!std::all_of(inputs.begin(), inputs.end(), [&](auto s) {
                       return s.lens()[l] == first_shape_lens[l];
                   }))
                {
                    MIGRAPH_THROW("Non-axis dimensions should match");
352
353
354
355
                }
            }
        }
        std::size_t new_dim_axis = 0;
Scott Thornton's avatar
Scott Thornton committed
356
        for(const auto& input : inputs)
357
358
359
360
361
362
363
364
365
        {
            const auto& lens = input.lens();
            new_dim_axis += lens[axis];
        }
        std::vector<std::size_t> new_lens;
        std::copy(first_shape_lens.begin(), first_shape_lens.end(), std::back_inserter(new_lens));
        new_lens[axis] = new_dim_axis;
        return {type, new_lens};
    }
Paul's avatar
Paul committed
366
367
368
369
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
370
371
};

372
373
374
375
376
struct slice
{
    std::vector<int64_t> axes;
    std::vector<int64_t> starts;
    std::vector<int64_t> ends;
Paul's avatar
Paul committed
377
378
379
380

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
381
        return pack(f(self.axes, "axes"), f(self.starts, "starts"), f(self.ends, "ends"));
Paul's avatar
Paul committed
382
383
    }

384
    std::string name() const { return "slice"; }
Scott Thornton's avatar
Scott Thornton committed
385
386

    auto fix_index(const std::vector<std::size_t>& lens, std::size_t axis, int64_t index) const
387
    {
Scott Thornton's avatar
Scott Thornton committed
388
        int64_t r = std::min(index, static_cast<int64_t>(lens[axis]));
Scott Thornton's avatar
Scott Thornton committed
389
390
        if(r < 0)
            r += lens[axis];
Scott Thornton's avatar
Scott Thornton committed
391
        return std::size_t(r);
Scott Thornton's avatar
Scott Thornton committed
392
393
394
395
396
397
398
    }

    auto compute_offset(const shape& s) const
    {
        const std::vector<std::size_t>& lens    = s.lens();
        const std::vector<std::size_t>& strides = s.strides();
        auto offset                             = 0;
Scott Thornton's avatar
Scott Thornton committed
399
        if(!axes.empty())
Scott Thornton's avatar
Scott Thornton committed
400
        {
Scott Thornton's avatar
Scott Thornton committed
401
402
403
404
405
            for(std::size_t i = 0; i < axes.size(); i++)
            {
                auto axis = axes[i];
                offset += fix_index(lens, axis, starts[i]) * strides[axis];
            }
406
        }
Scott Thornton's avatar
Scott Thornton committed
407
408
        else
        {
Scott Thornton's avatar
Scott Thornton committed
409
410
411
412
            for(std::size_t axis = 0; axis < lens.size(); axis++)
            {
                offset += fix_index(lens, axis, starts[axis]) * strides[axis];
            }
413
        }
Scott Thornton's avatar
Scott Thornton committed
414
415
416
417
418
        return offset;
    }

    shape compute_shape(std::vector<shape> inputs) const
    {
Scott Thornton's avatar
Scott Thornton committed
419
420
421
422
        auto input_shape        = inputs[0];
        auto t                  = input_shape.type();
        const auto& old_lens    = input_shape.lens();
        const auto& old_strides = input_shape.strides();
Scott Thornton's avatar
Scott Thornton committed
423
424
425
426
427
428
429
430
431
432
        // std::vector<int64_t> t_axes(old_lens.size());
        // if(axes.size() == 0)
        // {
        //     std::iota(t_axes.begin(), t_axes.end(), 0);
        // }
        // else
        // {
        //     std::copy(axes.begin(), axes.end(), t_axes.begin());
        // }
        if(starts.size() != axes.size() || axes.size() != ends.size())
Scott Thornton's avatar
Scott Thornton committed
433
        {
434
435
            MIGRAPH_THROW("inconsistent sizes");
        }
Scott Thornton's avatar
Scott Thornton committed
436
437
        std::vector<std::size_t> new_lens = old_lens;
        for(std::size_t i = 0; i < axes.size(); i++)
Scott Thornton's avatar
Scott Thornton committed
438
        {
Scott Thornton's avatar
Scott Thornton committed
439
440
441
            auto axis = axes[i];
            new_lens[axis] =
                fix_index(old_lens, axis, ends[i]) - fix_index(old_lens, axis, starts[i]);
442
443
444
445
446
        }
        return shape{t, new_lens, old_strides};
    }
    argument compute(context&, shape output_shape, std::vector<argument> args) const
    {
Scott Thornton's avatar
Scott Thornton committed
447
448
449
        auto input  = args[0];
        auto offset = compute_offset(input.get_shape()) * output_shape.type_size();
        return {std::move(output_shape), [=] { return input.data() + offset; }};
450
    }
Paul's avatar
Paul committed
451
452
453
454
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
455
456
457
458
459
};

struct squeeze
{
    std::vector<int64_t> axes;
Paul's avatar
Paul committed
460
461
462
463

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
464
        return pack(f(self.axes, "axes"));
Paul's avatar
Paul committed
465
466
    }

467
468
469
470
    std::string name() const { return "squeeze"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
        auto input_shape = inputs[0];
Scott Thornton's avatar
Scott Thornton committed
471
472
        auto type        = input_shape.type();
        auto old_lens    = input_shape.lens();
wsttiger's avatar
wsttiger committed
473
474
        if(std::any_of(
               axes.begin(), axes.end(), [&](auto axis) { return input_shape.lens()[axis] != 1; }))
Scott Thornton's avatar
Scott Thornton committed
475
        {
wsttiger's avatar
wsttiger committed
476
            MIGRAPH_THROW("squeeze axis dimension should be equal to 1");
477
478
        }
        std::vector<std::size_t> new_lens;
Scott Thornton's avatar
Scott Thornton committed
479
        if(axes.empty())
Scott Thornton's avatar
Scott Thornton committed
480
        {
wsttiger's avatar
wsttiger committed
481
482
483
484
            std::copy_if(old_lens.begin(),
                         old_lens.end(),
                         std::back_inserter(new_lens),
                         [](auto len) { return len != 1; });
485
        }
Scott Thornton's avatar
Scott Thornton committed
486
487
488
489
490
491
        else
        {
            for(std::size_t i = 0; i < old_lens.size(); i++)
            {
                if(std::find(axes.begin(), axes.end(), i) == axes.end())
                {
492
493
494
495
496
497
498
499
500
                    new_lens.push_back(old_lens[i]);
                }
            }
        }
        return shape{type, new_lens};
    }
    argument compute(context&, shape output_shape, std::vector<argument> args) const
    {
        return {std::move(output_shape), std::move(args.front().data)};
Scott Thornton's avatar
Scott Thornton committed
501
    }
Paul's avatar
Paul committed
502
503
504
505
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
506
507
508
509
510
};

struct unsqueeze
{
    std::vector<int64_t> axes;
Paul's avatar
Paul committed
511
512
513
514

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
515
        return pack(f(self.axes, "axes"));
Paul's avatar
Paul committed
516
517
    }

518
519
520
    std::string name() const { return "unsqueeze"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
Scott Thornton's avatar
Scott Thornton committed
521
522
523
        auto input_shape     = inputs[0];
        auto type            = input_shape.type();
        auto old_lens        = input_shape.lens();
524
525
526
        std::size_t new_size = old_lens.size() + axes.size();
        std::vector<std::size_t> new_lens(new_size);
        std::size_t p = 0;
Scott Thornton's avatar
Scott Thornton committed
527
528
529
530
        for(std::size_t i = 0; i < new_size; i++)
        {
            if(std::find(axes.begin(), axes.end(), i) != axes.end())
            {
531
                new_lens[i] = 1;
Scott Thornton's avatar
Scott Thornton committed
532
533
534
            }
            else
            {
535
536
537
538
539
540
541
542
543
                new_lens[i] = old_lens[p++];
            }
        }
        return shape{type, new_lens};
    }
    argument compute(context&, shape output_shape, std::vector<argument> args) const
    {
        return {std::move(output_shape), std::move(args.front().data)};
    }
Paul's avatar
Paul committed
544
545
546
547
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
548
549
};

Paul's avatar
Paul committed
550
551
552
struct reshape
{
    std::vector<int64_t> dims;
Paul's avatar
Paul committed
553
554
555
556

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
557
        return pack(f(self.dims, "dims"));
Paul's avatar
Paul committed
558
559
    }

Paul's avatar
Paul committed
560
    std::string name() const { return "reshape"; }
Paul's avatar
Paul committed
561
562
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
563
        check_shapes{inputs, *this}.has(1);
Paul's avatar
Paul committed
564
565
        auto&& idims = inputs.front().lens();
        std::vector<std::size_t> rdims(dims.begin(), dims.end());
566
567
568
        auto n_neg_dims = std::count(dims.begin(), dims.end(), -1);
        if(n_neg_dims > 1)
            MIGRAPH_THROW("Dimensions for reshape can only have one -1 dim");
Paul's avatar
Paul committed
569
        for(std::size_t i = 0; i < dims.size(); i++)
Paul's avatar
Paul committed
570
571
572
573
        {
            if(dims[i] == 0)
                rdims[i] = idims[i];
        }
574
575
576
577
578
579
580
581
582
583
584
        if(n_neg_dims > 0)
        {
            size_t missing_dim =
                -inputs.front().elements() /
                std::accumulate(rdims.begin(), rdims.end(), 1, std::multiplies<int64_t>());
            for(std::size_t i = 0; i < rdims.size(); i++)
            {
                if(dims[i] == -1)
                    rdims[i] = missing_dim;
            }
        }
Paul's avatar
Paul committed
585
586
587
        if(dims.back() == -1)
        {
            rdims.pop_back();
Paul's avatar
Paul committed
588
            std::copy(idims.begin() + rdims.size(), idims.end(), std::back_inserter(rdims));
Paul's avatar
Paul committed
589
        }
Scott Thornton's avatar
Scott Thornton committed
590
        shape s{inputs.front().type(), rdims};
Paul's avatar
Paul committed
591
        if(s.elements() != inputs.front().elements())
Paul's avatar
Paul committed
592
            MIGRAPH_THROW("Wrong number of elements for reshape");
Scott Thornton's avatar
Scott Thornton committed
593
        return s;
Paul's avatar
Paul committed
594
    }
Paul's avatar
Paul committed
595
    argument compute(context&, shape output_shape, std::vector<argument> args) const
Paul's avatar
Paul committed
596
    {
Paul's avatar
Paul committed
597
        return {std::move(output_shape), std::move(args.front().data)};
Paul's avatar
Paul committed
598
    }
Paul's avatar
Paul committed
599
600
601
602
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
Paul's avatar
Paul committed
603
604
};

Shucai Xiao's avatar
Shucai Xiao committed
605
struct dot
606
{
Paul's avatar
Paul committed
607
    float alpha = 1.0;
Paul's avatar
Paul committed
608
    float beta  = 0.0;
Paul's avatar
Paul committed
609
610
611
612

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
613
        return pack(f(self.alpha, "alpha"), f(self.beta, "beta"));
Paul's avatar
Paul committed
614
615
    }

Shucai Xiao's avatar
Shucai Xiao committed
616
    std::string name() const { return "dot"; }
617
618
    shape compute_shape(std::vector<shape> inputs) const
    {
Paul's avatar
Paul committed
619
        check_shapes{inputs, *this}.has(2).same_type();
620
621
        const shape& a = inputs.at(0);
        const shape& b = inputs.at(1);
Scott Thornton's avatar
Scott Thornton committed
622
        auto t         = a.type();
623

624
        if(a.lens()[1] != b.lens()[0])
Paul's avatar
Paul committed
625
626
            MIGRAPH_THROW("Inner dimensions do not match: {" + to_string_range(a.lens()) + "} x {" +
                          to_string_range(b.lens()) + "}");
Scott Thornton's avatar
Scott Thornton committed
627
        return {t, {a.lens()[0], b.lens()[1]}};
628
629
630
    }
};

631
struct unary
Scott Thornton's avatar
Scott Thornton committed
632
{
633
634
    shape compute_shape(std::vector<shape> inputs) const
    {
635
636
        check_shapes{inputs}.has(1);
        return inputs.at(0);
637
    }
Scott Thornton's avatar
Scott Thornton committed
638
639
};

640
641
struct identity : unary
{
642
    std::string name() const { return "identity"; }
643
644
645
};

struct abs : unary
Scott Thornton's avatar
Scott Thornton committed
646
{
647
    std::string name() const { return "abs"; }
Scott Thornton's avatar
Scott Thornton committed
648
649
};

650
struct exp : unary
Scott Thornton's avatar
Scott Thornton committed
651
{
652
    std::string name() const { return "exp"; }
Scott Thornton's avatar
Scott Thornton committed
653
654
};

655
struct sin : unary
Scott Thornton's avatar
Scott Thornton committed
656
{
657
    std::string name() const { return "sin"; }
Scott Thornton's avatar
Scott Thornton committed
658
659
};

660
struct cos : unary
Scott Thornton's avatar
Scott Thornton committed
661
{
662
    std::string name() const { return "cos"; }
Scott Thornton's avatar
Scott Thornton committed
663
664
};

665
struct tan : unary
Scott Thornton's avatar
Scott Thornton committed
666
{
667
    std::string name() const { return "tan"; }
Scott Thornton's avatar
Scott Thornton committed
668
669
};

670
struct asin : unary
Scott Thornton's avatar
Scott Thornton committed
671
{
672
    std::string name() const { return "asin"; }
Scott Thornton's avatar
Scott Thornton committed
673
674
};

675
struct acos : unary
Scott Thornton's avatar
Scott Thornton committed
676
{
677
    std::string name() const { return "acos"; }
Scott Thornton's avatar
Scott Thornton committed
678
679
};

680
struct atan : unary
Scott Thornton's avatar
Scott Thornton committed
681
{
682
    std::string name() const { return "atan"; }
Scott Thornton's avatar
Scott Thornton committed
683
684
};

685
struct tanh : unary
Scott Thornton's avatar
Scott Thornton committed
686
{
687
    std::string name() const { return "tanh"; }
Scott Thornton's avatar
Scott Thornton committed
688
689
};

690
struct sigmoid : unary
Scott Thornton's avatar
Scott Thornton committed
691
{
692
    std::string name() const { return "sigmoid"; }
Scott Thornton's avatar
Scott Thornton committed
693
694
};

695
struct neg : unary
Scott Thornton's avatar
Scott Thornton committed
696
{
697
    std::string name() const { return "neg"; }
Scott Thornton's avatar
Scott Thornton committed
698
699
};

Paul's avatar
Paul committed
700
701
702
703
704
705
706
707
708
709
struct softmax
{
    std::string name() const { return "softmax"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
        check_shapes{inputs}.has(1).only_dims(4);
        return inputs.at(0);
    }
};

710
struct flatten
Scott Thornton's avatar
Scott Thornton committed
711
{
Paul's avatar
Paul committed
712
    uint64_t axis = 0;
Paul's avatar
Paul committed
713
714
715
716

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
717
        return pack(f(self.axis, "axis"));
Paul's avatar
Paul committed
718
719
    }

Scott Thornton's avatar
Scott Thornton committed
720
    std::string name() const { return "flatten"; }
Paul's avatar
Paul committed
721
722
723
    shape compute_shape(std::vector<shape> inputs) const
    {
        check_shapes{inputs}.has(1);
Paul's avatar
Paul committed
724
725
        auto&& lens = inputs.front().lens();

Paul's avatar
Paul committed
726
        if(axis > lens.size())
Paul's avatar
Paul committed
727
        {
Paul's avatar
Paul committed
728
            MIGRAPH_THROW("axis for flatten must be less than tensor rank");
Paul's avatar
Paul committed
729
        }
Paul's avatar
Paul committed
730
731
732
733
        auto x =
            std::accumulate(lens.begin(), lens.begin() + axis, std::size_t{1}, std::multiplies<>{});
        auto y =
            std::accumulate(lens.begin() + axis, lens.end(), std::size_t{1}, std::multiplies<>{});
734
        return {inputs.at(0).type(), {x, y}};
Paul's avatar
Paul committed
735
736
737
    }
    argument compute(context&, shape output_shape, std::vector<argument> args) const
    {
Paul's avatar
Paul committed
738
        return {std::move(output_shape), std::move(args.front().data)};
Paul's avatar
Paul committed
739
    }
Paul's avatar
Paul committed
740
741
742
743
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
Scott Thornton's avatar
Scott Thornton committed
744
};
745
746
747
struct broadcast
{
    uint64_t axis = 0;
Paul's avatar
Paul committed
748
749
750
751

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
752
        return pack(f(self.axis, "axis"));
Paul's avatar
Paul committed
753
754
    }

Scott Thornton's avatar
Scott Thornton committed
755
    shape broadcast_shape;
756
757
758
    std::string name() const { return "broadcast"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
Scott Thornton's avatar
Scott Thornton committed
759
760
        auto t     = inputs.at(0).type();
        auto input = inputs.at(0);
Paul's avatar
Paul committed
761

Scott Thornton's avatar
Scott Thornton committed
762
        std::vector<size_t> bcast_strides(broadcast_shape.lens().size(), 0);
763

Scott Thornton's avatar
Scott Thornton committed
764
765
766
        if(std::all_of(broadcast_shape.lens().cbegin(), broadcast_shape.lens().cend(), [&](auto x) {
               return x == 1;
           }))
767
        {
Scott Thornton's avatar
Scott Thornton committed
768
            if(axis != 0)
Paul's avatar
Paul committed
769
                MIGRAPH_THROW("when broadcasting tensor of size 1, axis should be 0");
Scott Thornton's avatar
Scott Thornton committed
770
            return {t, broadcast_shape.lens(), std::move(bcast_strides)};
771
772
773
        }
        else
        {
Scott Thornton's avatar
Scott Thornton committed
774
            assert(broadcast_shape.lens().size() - axis >= input.lens().size());
Scott Thornton's avatar
Scott Thornton committed
775
776
            if(!std::equal(
                   input.lens().begin(), input.lens().end(), broadcast_shape.lens().begin() + axis))
Paul's avatar
Paul committed
777
                MIGRAPH_THROW("when broadcasting success sizes must match");
Paul's avatar
Paul committed
778
            std::copy(input.strides().begin(), input.strides().end(), bcast_strides.begin() + axis);
Scott Thornton's avatar
Scott Thornton committed
779
            return {t, broadcast_shape.lens(), std::move(bcast_strides)};
780
781
        }
    }
Paul's avatar
Paul committed
782
    argument compute(context&, shape output_shape, std::vector<argument> args) const
Scott Thornton's avatar
Scott Thornton committed
783
    {
Scott Thornton's avatar
Scott Thornton committed
784
        return {std::move(output_shape), std::move(args.at(0).data)};
Scott Thornton's avatar
Scott Thornton committed
785
    }
Paul's avatar
Paul committed
786
787
788
789
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
790
791
};

Khalique's avatar
Khalique committed
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
struct scalar
{
    shape scalar_bcast;

    std::string name() const { return "scalar"; }

    shape compute_shape(std::vector<shape> inputs) const
    {
        assert(check_shapes{inputs}.has(1).only_dims(1).size() == 1);
        auto t     = inputs.at(0).type();
        auto input = inputs.at(0);
        std::vector<std::size_t> strides(scalar_bcast.lens().size(), 0);
        return {t, scalar_bcast.lens(), strides};
    }

    argument compute(context&, shape output_shape, std::vector<argument> args) const
    {
        return {std::move(output_shape), std::move(args.at(0).data)};
    }
Paul's avatar
Paul committed
811
812
813
814
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
Khalique's avatar
Khalique committed
815
816
};

817
struct binary
Scott Thornton's avatar
Scott Thornton committed
818
{
819
820
    shape compute_shape(std::vector<shape> inputs) const
    {
821
822
        check_shapes{inputs}.has(2).same_type().same_dims();
        return inputs.at(0);
823
    }
Scott Thornton's avatar
Scott Thornton committed
824
825
};

826
827
828
829
830
831
struct add : binary
{
    std::string name() const { return "add"; }
};

struct sub : binary
Scott Thornton's avatar
Scott Thornton committed
832
833
834
835
{
    std::string name() const { return "sub"; }
};

836
struct mul : binary
Scott Thornton's avatar
Scott Thornton committed
837
838
839
840
{
    std::string name() const { return "mul"; }
};

841
struct div : binary
Scott Thornton's avatar
Scott Thornton committed
842
843
844
845
{
    std::string name() const { return "div"; }
};

Paul's avatar
Paul committed
846
847
848
849
struct load
{
    shape s;
    std::size_t offset = 0;
Paul's avatar
Paul committed
850
851
852
853

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
854
        return pack(f(self.s, "shape"), f(self.offset, "offset"));
Paul's avatar
Paul committed
855
856
    }

Paul's avatar
Paul committed
857
858
859
860
861
862
863
864
865
866
    std::string name() const { return "load"; }
    shape compute_shape(const std::vector<shape>& inputs) const
    {
        check_shapes{inputs}.has(1);
        return s;
    }
    argument compute(context&, const shape&, const std::vector<argument>& args) const
    {
        return {s, args[0].data() + offset};
    }
Paul's avatar
Paul committed
867
868
869
870
    int output_alias(const std::vector<shape>&) const
    {
        return 0;
    }
Paul's avatar
Paul committed
871
872
};

Paul's avatar
Paul committed
873
struct outline
Scott Thornton's avatar
Scott Thornton committed
874
{
Paul's avatar
Paul committed
875
    shape s;
Paul's avatar
Paul committed
876
877
878
879

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
Paul's avatar
Paul committed
880
        return pack(f(self.s, "shape"));
Paul's avatar
Paul committed
881
882
    }

Paul's avatar
Paul committed
883
    std::string name() const { return "outline"; }
Paul's avatar
Paul committed
884
    shape compute_shape(const std::vector<shape>& inputs) const
Paul's avatar
Paul committed
885
    {
Paul's avatar
Paul committed
886
        check_shapes{inputs, *this}.has(0);
Paul's avatar
Paul committed
887
888
        return s;
    }
Paul's avatar
Paul committed
889
890
891
892
    argument compute(context&, const shape&, const std::vector<argument>&) const
    {
        return {s, nullptr};
    }
Scott Thornton's avatar
Scott Thornton committed
893
894
};

895
} // namespace op
Paul's avatar
Paul committed
896
} // namespace migraph
Paul's avatar
Paul committed
897
898

#endif