Operators

operation

struct migraphx::internal::operation

The operation interface represents an action an instruction will perform. All operation classes must be CopyConstructible.

Public Functions

std::string name() const

A unique name identifying the operation.

void finalize(context &ctx)

An optional method that can be used to finalize the operator before running.

shape compute_shape(const std::vector<shape> &input) const

This is used to compute the resulting shape from an operation. If an operation cannot be run with input shapes, then it should throw an exception.

argument compute(context &ctx, const shape &output, const std::vector<argument> &input) const

This performs the operation’s computation.

This method can be optional when the operation is only used as a placeholder to be lowered later on.

Parameters

• ctx – This is the context created by the target during compilation. Implementations can use the target’s context class rather than the context interface class.

• output – This is the output shape. It is equivalent to running compute_shape with each shape of the argument.

• input – This is the argument result from the previous instruction’s computation.

Returns

Return an argument of the result computation. The shape of argument should be the same the output shape.

std::ptrdiff_t output_alias(const std::vector<shape> &input) const

An optional method to return which argument the output will alias. If there is no aliased output then -1 can be returned.

Friends

friend friend std::ostream & operator<< (std::ostream &os, const operation &op)

An optional stream operator to print the operation. When this is not implemented, it will just print the operation’s name.

bool migraphx::internal::is_context_free(const operation &x)

Returns true if operation does not require a context to run compute.

bool migraphx::internal::has_finalize(const operation &x)

Returns true if the operation has a finalize method.

operators

namespace migraphx::internal::op

Enums

enum padding_mode_t

Values:

enumerator default_

enumerator same

enumerator valid

enum rnn_direction

Values:

enumerator forward

enumerator reverse

enumerator bidirectional

enum normalize_attribute

Values:

enumerator use_len

enumerator use_output

enumerator clip_max

enumerator clip_min

enumerator include_max

enumerator include_min

enumerator normalize_padding

Functions

std::ostream &operator<<(std::ostream &os, rnn_direction v)

struct abs : public migraphx::internal::op::unary<abs>

#include <migraphx/op/abs.hpp>

Public Functions

inline auto apply() const

struct acos : public migraphx::internal::op::unary<acos>

#include <migraphx/op/acos.hpp>

Public Functions

inline auto apply() const

struct acosh : public migraphx::internal::op::unary<acosh>

#include <migraphx/op/acosh.hpp>

Public Functions

inline auto apply() const

struct add : public migraphx::internal::op::binary<add>

#include <migraphx/op/add.hpp>

Public Functions

inline value attributes() const

inline std::string point_function() const

inline auto apply() const

struct argmax

#include <migraphx/op/argmax.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

template<class T>
inline int64_t calc_argmax(T &input, std::vector<std::size_t> &indices, size_t item_num) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t axis = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct argmin

#include <migraphx/op/argmin.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

template<class T>
inline int64_t calc_argmin(T &input, std::vector<std::size_t> &indices, size_t item_num) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t axis = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct as_shape

#include <migraphx/op/as_shape.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

shape s

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct asin : public migraphx::internal::op::unary<asin>

#include <migraphx/op/asin.hpp>

Public Functions

inline auto apply() const

struct asinh : public migraphx::internal::op::unary<asinh>

#include <migraphx/op/asinh.hpp>

Public Functions

inline auto apply() const

struct atan : public migraphx::internal::op::unary<atan>

#include <migraphx/op/atan.hpp>

Public Functions

inline auto apply() const

struct atanh : public migraphx::internal::op::unary<atanh>

#include <migraphx/op/atanh.hpp>

Public Functions

inline auto apply() const

struct batch_norm_inference

#include <migraphx/op/batch_norm_inference.hpp>

Public Types

enum bn_infer_mode_t

Values:

enumerator per_activation

enumerator spatial

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

float epsilon = 1.0e-6f

float momentum = 0.9f

bn_infer_mode_t bn_mode = spatial

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

template<class Derived>
struct binary : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/binary.hpp>

Public Functions

inline std::string point_function() const

inline std::string point_op() const

inline value base_attributes() const

inline value attributes() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct broadcast

#include <migraphx/op/broadcast.hpp>

The broadcast operator performs the numpy-style broadcasting of an axis of a given tensor. This is achieved primarily by setting the stride of the broadcasted axis to zero. Linear indicies are computed from multi-indicies by computing the inner product on the multi-index with the strides. For example, if we have a tensor A(2,3) it has lengths of (2,3) and strides of (3,1). If we want to compute the linear offset that corresponds to the element on the 2nd row (i = 1) and 3rd column (j = 2), we compute the following inner product (1,2) dot (3, 1) = 1*3 + 2*1 = 5. It is obvious from there that we can negate the effects of a given axis by setting the stride of that axis to zero.

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

uint64_t axis = 0

std::vector<std::size_t> broadcast_lens

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct capture

#include <migraphx/op/capture.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(context&, const shape&, const std::vector<argument> &args) const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::size_t ins_index

std::function<void(std::size_t ins_index, std::vector<argument>)> f = {}

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct ceil : public migraphx::internal::op::unary<ceil>

#include <migraphx/op/ceil.hpp>

Public Functions

inline auto apply() const

struct clip

#include <migraphx/op/clip.hpp>

Public Functions

inline std::string name() const

inline value attributes() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct concat

#include <migraphx/op/concat.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline std::vector<std::size_t> compute_offsets(const shape &output_shape, const std::vector<argument> &args) const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t axis = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct contiguous

#include <migraphx/op/contiguous.hpp>

The contiguous operator takes a non-standard input tensor and returns the same tensor but in standard form. For example, if input tensor A which has lens = (4,5) is first transposed, i.e. lens = (5,4), this tensor’s data layout remained the same during the transpose operation; only it’s shape lengths and strides were changed. This leaves the tensor in a non-standard form. The contiguous operator copies the underlying data such that resulting tensor is returned to a standard form.

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

inline auto apply() const

struct convert : public migraphx::internal::op::unary<convert>

#include <migraphx/op/convert.hpp>

Public Functions

inline shape compute_shape(std::vector<shape> inputs) const

inline std::string point_op() const

inline auto apply() const

inline convert(shape::type_t t)

inline convert()

Public Members

shape::type_t target_type = shape::half_type

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct convolution

#include <migraphx/op/convolution.hpp>

Public Functions

inline std::string name() const

inline void check_attribute_size() const

inline value attributes() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline size_t kdims() const

Public Members

std::vector<std::size_t> padding = {0, 0}

std::vector<std::size_t> stride = {1, 1}

std::vector<std::size_t> dilation = {1, 1}

int group = 1

padding_mode_t padding_mode = default_

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct cos : public migraphx::internal::op::unary<cos>

#include <migraphx/op/cos.hpp>

Public Functions

inline auto apply() const

struct cosh : public migraphx::internal::op::unary<cosh>

#include <migraphx/op/cosh.hpp>

Public Functions

inline auto apply() const

struct deconvolution

#include <migraphx/op/deconvolution.hpp>

Public Functions

inline std::string name() const

inline void check_attribute_size() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline size_t kdims() const

Public Members

std::vector<std::size_t> padding = {0, 0}

std::vector<std::size_t> stride = {1, 1}

std::vector<std::size_t> dilation = {1, 1}

padding_mode_t padding_mode = default_

int group = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct dequantizelinear

#include <migraphx/op/dequantizelinear.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct div : public migraphx::internal::op::binary<div>

#include <migraphx/op/div.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct dot

#include <migraphx/op/dot.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

struct elu

#include <migraphx/op/elu.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

float alpha = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct equal : public migraphx::internal::op::binary<equal>

#include <migraphx/op/equal.hpp>

Public Functions

inline value attributes() const

inline std::string point_function() const

inline auto apply() const

struct erf : public migraphx::internal::op::unary<erf>

#include <migraphx/op/erf.hpp>

Public Functions

inline auto apply() const

struct exp : public migraphx::internal::op::unary<exp>

#include <migraphx/op/exp.hpp>

Public Functions

inline auto apply() const

struct flatten

#include <migraphx/op/flatten.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

int64_t axis = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct floor : public migraphx::internal::op::unary<floor>

#include <migraphx/op/floor.hpp>

Public Functions

inline auto apply() const

struct gather

#include <migraphx/op/gather.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t axis = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct get_tuple_elem

#include <migraphx/op/get_tuple_elem.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape&, std::vector<argument> args) const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::size_t index = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct greater : public migraphx::internal::op::binary<greater>

#include <migraphx/op/greater.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct gru

#include <migraphx/op/gru.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

std::size_t hidden_size = 1

std::vector<operation> actv_funcs = {sigmoid{}, tanh{}}

rnn_direction direction = rnn_direction::forward

float clip = 0.0f

int linear_before_reset = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct highest

#include <migraphx/op/reduce_op.hpp>

Public Functions

template<class T>
inline operator T() const

struct identity

#include <migraphx/op/identity.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape, std::vector<argument> args) const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

struct if_op

#include <migraphx/op/if_op.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs, std::vector<module_ref> mods) const

inline argument compute(const shape&, const std::vector<argument> &args, const std::vector<module_ref> &mods, const std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)> &run) const

struct im2col

#include <migraphx/op/im2col.hpp>

Public Functions

inline std::string name() const

inline value attributes() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

Public Members

std::vector<std::size_t> padding = {0, 0}

std::vector<std::size_t> stride = {1, 1}

std::vector<std::size_t> dilation = {1, 1}

padding_mode_t padding_mode = default_

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct leaky_relu

#include <migraphx/op/leaky_relu.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

float alpha = 0.01

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct less : public migraphx::internal::op::binary<less>

#include <migraphx/op/less.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct load

#include <migraphx/op/load.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs) const

inline argument compute(const shape&, const std::vector<argument> &args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

shape s

std::size_t offset = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

Friends

inline friend friend std::ostream & operator<< (std::ostream &os, const load &op)

struct log : public migraphx::internal::op::unary<log>

#include <migraphx/op/log.hpp>

Public Functions

inline auto apply() const

struct logical_and : public migraphx::internal::op::binary<logical_and>

#include <migraphx/op/logical_and.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct logical_or : public migraphx::internal::op::binary<logical_or>

#include <migraphx/op/logical_or.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct logical_xor : public migraphx::internal::op::binary<logical_xor>

#include <migraphx/op/logical_xor.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct logsoftmax

#include <migraphx/op/logsoftmax.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline auto output() const

Public Members

int64_t axis = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct loop

#include <migraphx/op/loop.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs, std::vector<module_ref> mods) const

inline argument compute(context &ctx, const shape &out_shape, const std::vector<argument> &args, const std::vector<module_ref> &mods, const std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)> &run) const

Public Members

int64_t max_iterations = 10

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct ref_loop

#include <migraphx/op/loop.hpp>

Public Functions

template<class T>
inline void copy(context&, const argument &src, T &dst) const

template<class T>
inline void copy(context&, T src, const argument &dst) const

inline void append(const std::vector<argument> &iter_state, const std::vector<argument> &concatenated_outputs, int iter) const

inline void set_zero(context&, const std::vector<argument> &concatenated_outputs, int iter) const

inline std::unordered_map<std::string, int> get_output_params(const module&) const

Public Members

int64_t max_iterations = 0

struct lowest

#include <migraphx/op/reduce_op.hpp>

Public Functions

template<class T>
inline operator T() const

struct lrn

#include <migraphx/op/lrn.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

float alpha = 0.0001

float beta = 0.75

float bias = 1.0

int size = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct lstm

#include <migraphx/op/lstm.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

std::size_t hidden_size = 1

std::vector<operation> actv_funcs = {sigmoid{}, tanh{}, tanh{}}

rnn_direction direction = rnn_direction::forward

float clip = 0.0f

int input_forget = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct max : public migraphx::internal::op::binary<max>

#include <migraphx/op/max.hpp>

Public Functions

inline value attributes() const

inline auto apply() const

struct min : public migraphx::internal::op::binary<min>

#include <migraphx/op/min.hpp>

Public Functions

inline value attributes() const

inline auto apply() const

struct mul : public migraphx::internal::op::binary<mul>

#include <migraphx/op/mul.hpp>

Public Functions

inline value attributes() const

inline std::string point_function() const

inline auto apply() const

struct multibroadcast

#include <migraphx/op/multibroadcast.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<std::size_t> output_lens

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct multinomial

#include <migraphx/op/multinomial.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

shape::type_t dtype = shape::type_t::int32_type

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct neg : public migraphx::internal::op::unary<neg>

#include <migraphx/op/neg.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct nonmaxsuppression

#include <migraphx/op/nonmaxsuppression.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

template<class T>
inline box batch_box(const T *boxes, std::size_t bidx) const

inline bool suppress_by_iou(box b1, box b2, float iou_threshold) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

bool center_point_box = false

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct box

#include <migraphx/op/nonmaxsuppression.hpp>

Public Functions

inline void sort()

inline std::array<float, 2> &operator[](std::size_t i)

inline float area() const

Public Members

std::array<float, 2> x

std::array<float, 2> y

struct nonzero

#include <migraphx/op/nonzero.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct one

#include <migraphx/op/reduce_op.hpp>

Public Functions

template<class T>
inline operator T() const

template<class Derived>
struct op_name

#include <migraphx/op/name.hpp>

Create name from class.

Subclassed by migraphx::internal::op::binary< Derived >, migraphx::internal::op::prefix_scan_op< Derived >, migraphx::internal::op::reduce_op< Derived >, migraphx::internal::op::unary< Derived >

Public Functions

inline std::string name() const

struct outline

#include <migraphx/op/outline.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs) const

inline argument compute(const shape&, const std::vector<argument>&) const

Public Members

shape s

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct pad

#include <migraphx/op/pad.hpp>

Public Types

enum pad_op_mode_t

Values:

enumerator constant_pad

enumerator reflect_pad

enumerator edge_pad

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline std::size_t pad_ndims() const

inline bool symmetric() const

Public Members

std::vector<int64_t> pads

float value = 0.0f

pad_op_mode_t mode = constant_pad

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct pointwise

#include <migraphx/op/pointwise.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs, std::vector<module_ref> mods) const

inline argument compute(const shape &output_shape, const std::vector<argument> &args, const std::vector<module_ref> &mods, const std::function<std::vector<argument>(module_ref&, const std::unordered_map<std::string, argument>&)> &run) const

struct pooling

#include <migraphx/op/pooling.hpp>

Public Functions

inline std::string name() const

inline void check_attribute_size() const

inline value attributes() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline size_t kdims() const

Public Members

std::string mode = "average"

std::vector<std::size_t> padding = {0, 0}

std::vector<std::size_t> stride = {1, 1}

std::vector<std::size_t> lengths = {1, 1}

bool ceil_mode = false

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct pow : public migraphx::internal::op::binary<pow>

#include <migraphx/op/pow.hpp>

Public Functions

inline auto apply() const

template<class Derived>
struct prefix_scan_op : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/prefix_scan_op.hpp>

Public Functions

inline value attributes() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape&, std::vector<argument> args) const

inline auto init() const

inline prefix_scan_op()

inline prefix_scan_op(int64_t ax)

inline prefix_scan_op(int64_t ax, bool excl)

inline prefix_scan_op(int64_t ax, bool excl, bool rev)

Public Members

int64_t axis

bool exclusive = false

bool reverse = false

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct prefix_scan_sum : public migraphx::internal::op::prefix_scan_op<prefix_scan_sum>

#include <migraphx/op/prefix_scan_sum.hpp>

Public Functions

inline prefix_scan_sum()

inline prefix_scan_sum(int64_t ax)

inline prefix_scan_sum(int64_t ax, bool excl)

inline prefix_scan_sum(int64_t ax, bool excl, bool rev)

inline auto op() const

struct prelu : public migraphx::internal::op::binary<prelu>

#include <migraphx/op/prelu.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct quant_convolution

#include <migraphx/op/quant_convolution.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline void check_attribute_size() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline size_t kdims() const

Public Members

std::vector<std::size_t> padding = {0, 0}

std::vector<std::size_t> stride = {1, 1}

std::vector<std::size_t> dilation = {1, 1}

padding_mode_t padding_mode = default_

int group = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct quant_dot

#include <migraphx/op/quant_dot.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

struct quantizelinear

#include <migraphx/op/quantizelinear.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct recip : public migraphx::internal::op::unary<recip>

#include <migraphx/op/recip.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct reduce_max : public migraphx::internal::op::reduce_op<reduce_max>

#include <migraphx/op/reduce_max.hpp>

Public Functions

inline reduce_max()

inline reduce_max(std::vector<int64_t> ax)

inline auto op() const

inline auto init() const

struct reduce_mean : public migraphx::internal::op::reduce_op<reduce_mean>

#include <migraphx/op/reduce_mean.hpp>

Public Functions

inline reduce_mean()

inline reduce_mean(std::vector<int64_t> ax)

inline auto op() const

inline auto output(const shape &s) const

struct reduce_min : public migraphx::internal::op::reduce_op<reduce_min>

#include <migraphx/op/reduce_min.hpp>

Public Functions

inline reduce_min()

inline reduce_min(std::vector<int64_t> ax)

inline auto op() const

inline auto init() const

template<class Derived>
struct reduce_op : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/reduce_op.hpp>

Public Functions

inline value attributes() const

inline std::vector<int64_t> tune_axes(std::size_t n_dim) const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

template<class T>
inline void tune_dims(const std::vector<int64_t> &tuned_axes, const std::vector<T> &in_lens, std::vector<T> &out_lens) const

template<class T>
inline void reduce(tensor_view<T> &input, shape &batch_shape, std::vector<int64_t> &tuned_axes, std::vector<std::size_t> &out_idx, tensor_view<T> &output) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

inline auto init() const

inline auto input() const

inline auto output(const shape&) const

inline reduce_op()

inline reduce_op(std::vector<int64_t> ax)

Public Members

std::vector<std::int64_t> axes = {}

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct reduce_prod : public migraphx::internal::op::reduce_op<reduce_prod>

#include <migraphx/op/reduce_prod.hpp>

Public Functions

inline reduce_prod()

inline reduce_prod(std::vector<int64_t> ax)

inline auto op() const

inline auto init() const

struct reduce_sum : public migraphx::internal::op::reduce_op<reduce_sum>

#include <migraphx/op/reduce_sum.hpp>

Public Functions

inline reduce_sum()

inline reduce_sum(std::vector<int64_t> ax)

inline auto op() const

struct relu : public migraphx::internal::op::unary<relu>

#include <migraphx/op/relu.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct reshape

#include <migraphx/op/reshape.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> dims

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct reverse

#include <migraphx/op/reverse.hpp>

Public Functions

inline std::string name() const

inline value attributes() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &s, std::vector<argument> args) const

Public Members

std::vector<int64_t> axes

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct rnn

#include <migraphx/op/rnn.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

std::size_t hidden_size = 1

std::vector<operation> actv_funcs = {tanh{}, tanh{}}

rnn_direction direction = rnn_direction::forward

float clip = 0.0f

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct rnn_last_cell_output

#include <migraphx/op/rnn_last_cell_output.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

struct rnn_last_hs_output

#include <migraphx/op/rnn_last_hs_output.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

struct rnn_var_sl_last_output

#include <migraphx/op/rnn_var_sl_last_output.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

Public Members

rnn_direction direction = rnn_direction::forward

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct rnn_var_sl_shift_output

#include <migraphx/op/rnn_variable_seq_lens.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

std::string output_name = "hidden_states"

rnn_direction direction = rnn_direction::forward

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct rnn_var_sl_shift_sequence

#include <migraphx/op/rnn_variable_seq_lens.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct roialign

#include <migraphx/op/roialign.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline auto calc_pos_weight(const std::array<std::size_t, 2> &dims, const shape &comp_s, const std::array<float, 2> &roi_start, const std::array<float, 2> &bin_size, const std::array<std::size_t, 2> &bin_grid_size) const

template<class T, class Op>
inline std::tuple<double, int64_t> calc_pooling(const T &data, const std::array<std::size_t, 2> &bin_grid_size, const std::vector<pos_weight> &pos_weights, int64_t index, Op op) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

std::string coord_trans_mode = "half_pixel"

std::string mode = "avg"

int64_t output_height = 1

int64_t output_width = 1

int64_t sampling_ratio = 0

float spatial_scale = 1.0f

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct avg_pool

#include <migraphx/op/roialign.hpp>

Public Functions

inline double init()

inline double operator()(double x, double y)

inline double final(double x, std::size_t y)

struct max_pool

#include <migraphx/op/roialign.hpp>

Public Functions

inline double init()

inline double operator()(double x, double y)

inline double final(double x, std::size_t)

struct pos_weight

#include <migraphx/op/roialign.hpp>

Public Members

std::array<std::size_t, 4> pos = {0, 0, 0, 0}

std::array<float, 4> w = {0.0f, 0.0f, 0.0f, 0.0f}

struct round : public migraphx::internal::op::unary<round>

#include <migraphx/op/round.hpp>

Public Functions

inline auto apply() const

struct rsqrt : public migraphx::internal::op::unary<rsqrt>

#include <migraphx/op/rsqrt.hpp>

Public Functions

inline auto apply() const

struct scalar

#include <migraphx/op/scalar.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<std::size_t> scalar_bcast_lens

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct scatter

#include <migraphx/op/scatter.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t axis = 0

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct sigmoid : public migraphx::internal::op::unary<sigmoid>

#include <migraphx/op/sigmoid.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct sign : public migraphx::internal::op::unary<sign>

#include <migraphx/op/sign.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct sin : public migraphx::internal::op::unary<sin>

#include <migraphx/op/sin.hpp>

Public Functions

inline auto apply() const

struct sinh : public migraphx::internal::op::unary<sinh>

#include <migraphx/op/sinh.hpp>

Public Functions

inline auto apply() const

struct slice

#include <migraphx/op/slice.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline auto fix_index(const std::vector<std::size_t> &lens, std::size_t axis, int64_t index) const

inline auto compute_offset(const shape &s) const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> axes

std::vector<int64_t> starts

std::vector<int64_t> ends

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct softmax

#include <migraphx/op/softmax.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline auto output() const

Public Members

int64_t axis = 1

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct sqdiff : public migraphx::internal::op::binary<sqdiff>

#include <migraphx/op/sqdiff.hpp>

Public Functions

inline std::string point_op() const

inline auto apply() const

struct sqrt : public migraphx::internal::op::unary<sqrt>

#include <migraphx/op/sqrt.hpp>

Public Functions

inline auto apply() const

struct squeeze

#include <migraphx/op/squeeze.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> axes

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct step

#include <migraphx/op/step.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> axes

std::vector<int64_t> steps

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct sub : public migraphx::internal::op::binary<sub>

#include <migraphx/op/sub.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

struct tan : public migraphx::internal::op::unary<tan>

#include <migraphx/op/tan.hpp>

Public Functions

inline auto apply() const

struct tanh : public migraphx::internal::op::unary<tanh>

#include <migraphx/op/tanh.hpp>

Public Functions

inline auto apply() const

struct topk

#include <migraphx/op/topk.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

template<class T, class Compare>
inline heap_vector<T, Compare> make_heap(std::vector<T> val, Compare compare) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

Public Members

int64_t k = 1

int64_t axis = 0

bool largest = true

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

template<class T, class Compare>
struct heap_vector

#include <migraphx/op/topk.hpp>

Public Functions

inline heap_vector(const std::vector<T> &val, Compare comp)

inline void try_push(T val)

inline std::vector<T> sort()

Public Members

std::vector<T> data

Compare compare

struct transpose

#include <migraphx/op/transpose.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> dims

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

template<class Derived>
struct unary : public migraphx::internal::op::op_name<Derived>

#include <migraphx/op/unary.hpp>

Public Functions

inline std::string point_function() const

inline std::string point_op() const

inline value base_attributes() const

inline value attributes() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct unary_not : public migraphx::internal::op::unary<unary_not>

#include <migraphx/op/unary_not.hpp>

Public Functions

inline std::string point_function() const

inline auto apply() const

inline std::string name() const

struct undefined

#include <migraphx/op/undefined.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(const std::vector<shape> &inputs) const

inline argument compute(const shape&, const std::vector<argument>&) const

struct unknown

#include <migraphx/op/unknown.hpp>

Public Functions

inline std::string name() const

inline shape compute_shape(std::vector<shape> input) const

Public Members

std::string op

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

Friends

inline friend friend std::ostream & operator<< (std::ostream &os, const unknown &x)

struct unsqueeze

#include <migraphx/op/unsqueeze.hpp>

Public Functions

inline value attributes() const

inline std::string name() const

inline shape normalize_compute_shape(std::vector<shape> inputs) const

inline argument compute(shape output_shape, std::vector<argument> args) const

inline lifetime get_lifetime() const

inline std::ptrdiff_t output_alias(const std::vector<shape>&) const

Public Members

std::vector<int64_t> axes

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)

struct where

#include <migraphx/op/where.hpp>

Public Functions

inline std::string name() const

inline value attributes() const

inline shape compute_shape(std::vector<shape> inputs) const

inline argument compute(const shape &output_shape, std::vector<argument> args) const

struct zero

#include <migraphx/op/reduce_op.hpp>

Public Functions

template<class T>
inline operator T() const