Operators

Contents

Operators#

Applies to Linux

2023-06-14

20 min read time

operation#

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

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 op#

Enums

enum padding_mode_t#

Values:

enumerator default_#

enumerator same_lower#

enumerator same_upper#

enum class pooling_mode#

Values:

enumerator average#

enumerator max#

enumerator lpnorm#

enum class rnn_direction#

Values:

enumerator forward#

enumerator reverse#

enumerator bidirectional#

enum class 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, pooling_mode v)#

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

struct abs : public migraphx::internal::op::unary<abs>#: #include <migraphx/op/abs.hpp>

struct acos : public migraphx::internal::op::unary<acos>#: #include <migraphx/op/acos.hpp>

struct acosh : public migraphx::internal::op::unary<acosh>#: #include <migraphx/op/acosh.hpp>

struct add : public migraphx::internal::op::binary<add>#: #include <migraphx/op/add.hpp>

struct allocate#: #include <migraphx/op/allocate.hpp>

struct argmax#: #include <migraphx/op/argmax.hpp>

struct argmin#: #include <migraphx/op/argmin.hpp>

struct as_shape#: #include <migraphx/op/as_shape.hpp>

struct asin : public migraphx::internal::op::unary<asin>#: #include <migraphx/op/asin.hpp>

struct asinh : public migraphx::internal::op::unary<asinh>#: #include <migraphx/op/asinh.hpp>

struct atan : public migraphx::internal::op::unary<atan>#: #include <migraphx/op/atan.hpp>

struct atanh : public migraphx::internal::op::unary<atanh>#: #include <migraphx/op/atanh.hpp>

template<class Derived> struct binary : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/binary.hpp>

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.

struct capture#: #include <migraphx/op/capture.hpp>

struct ceil : public migraphx::internal::op::unary<ceil>#: #include <migraphx/op/ceil.hpp>

struct clip#: #include <migraphx/op/clip.hpp>

struct concat#: #include <migraphx/op/concat.hpp>

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.

struct convert : public migraphx::internal::op::unary<convert>#: #include <migraphx/op/convert.hpp>

struct convolution#: #include <migraphx/op/convolution.hpp>

struct cos : public migraphx::internal::op::unary<cos>#: #include <migraphx/op/cos.hpp>

struct cosh : public migraphx::internal::op::unary<cosh>#: #include <migraphx/op/cosh.hpp>

struct deconvolution#: #include <migraphx/op/deconvolution.hpp>

struct dequantizelinear#: #include <migraphx/op/dequantizelinear.hpp>

struct div : public migraphx::internal::op::binary<div>#: #include <migraphx/op/div.hpp>

struct dot#: #include <migraphx/op/dot.hpp>

struct elu#: #include <migraphx/op/elu.hpp>

struct equal : public migraphx::internal::op::binary<equal>#: #include <migraphx/op/equal.hpp>

struct erf : public migraphx::internal::op::unary<erf>#: #include <migraphx/op/erf.hpp>

struct exp : public migraphx::internal::op::unary<exp>#: #include <migraphx/op/exp.hpp>

struct flatten#: #include <migraphx/op/flatten.hpp>

struct floor : public migraphx::internal::op::unary<floor>#: #include <migraphx/op/floor.hpp>

struct fmod : public migraphx::internal::op::binary<fmod>#: #include <migraphx/op/fmod.hpp>

struct gather#: #include <migraphx/op/gather.hpp>

struct gathernd#: #include <migraphx/op/gathernd.hpp>

struct get_tuple_elem#: #include <migraphx/op/get_tuple_elem.hpp>

struct greater : public migraphx::internal::op::binary<greater>#: #include <migraphx/op/greater.hpp>

struct gru#: #include <migraphx/op/gru.hpp>

struct highest#: #include <migraphx/op/reduce_op.hpp>

struct identity#: #include <migraphx/op/identity.hpp>

struct if_op#: #include <migraphx/op/if_op.hpp>

struct im2col#: #include <migraphx/op/im2col.hpp>

struct isnan : public migraphx::internal::op::unary<isnan>#: #include <migraphx/op/isnan.hpp>

struct leaky_relu#: #include <migraphx/op/leaky_relu.hpp>

struct less : public migraphx::internal::op::binary<less>#: #include <migraphx/op/less.hpp>

struct load#: #include <migraphx/op/load.hpp>

struct log : public migraphx::internal::op::unary<log>#: #include <migraphx/op/log.hpp>

struct logical_and : public migraphx::internal::op::binary<logical_and>#: #include <migraphx/op/logical_and.hpp>

struct logical_or : public migraphx::internal::op::binary<logical_or>#: #include <migraphx/op/logical_or.hpp>

struct logical_xor : public migraphx::internal::op::binary<logical_xor>#: #include <migraphx/op/logical_xor.hpp>

struct logsoftmax#: #include <migraphx/op/logsoftmax.hpp>

struct loop#: #include <migraphx/op/loop.hpp>

struct lowest#: #include <migraphx/op/reduce_op.hpp>

struct lrn#: #include <migraphx/op/lrn.hpp>

struct lstm#: #include <migraphx/op/lstm.hpp>

struct max : public migraphx::internal::op::binary<max>#: #include <migraphx/op/max.hpp>

struct min : public migraphx::internal::op::binary<min>#: #include <migraphx/op/min.hpp>

struct mod : public migraphx::internal::op::binary<mod>#: #include <migraphx/op/mod.hpp>

struct mul : public migraphx::internal::op::binary<mul>#: #include <migraphx/op/mul.hpp>

struct multibroadcast#: #include <migraphx/op/multibroadcast.hpp>

struct multinomial#: #include <migraphx/op/multinomial.hpp>

struct neg : public migraphx::internal::op::unary<neg>#: #include <migraphx/op/neg.hpp>

struct nonmaxsuppression#: #include <migraphx/op/nonmaxsuppression.hpp>

struct nonzero#: #include <migraphx/op/nonzero.hpp>

struct one#: #include <migraphx/op/reduce_op.hpp>

template<class Derived> struct op_name#

#include <migraphx/op/name.hpp>

Create name from class.

Subclassed by migraphx::internal::op::binary< add >, migraphx::internal::op::binary< div >, migraphx::internal::op::binary< equal >, migraphx::internal::op::binary< fmod >, migraphx::internal::op::binary< greater >, migraphx::internal::op::binary< less >, migraphx::internal::op::binary< logical_and >, migraphx::internal::op::binary< logical_or >, migraphx::internal::op::binary< logical_xor >, migraphx::internal::op::binary< max >, migraphx::internal::op::binary< min >, migraphx::internal::op::binary< mod >, migraphx::internal::op::binary< mul >, migraphx::internal::op::binary< pow >, migraphx::internal::op::binary< prelu >, migraphx::internal::op::binary< sqdiff >, migraphx::internal::op::binary< sub >, migraphx::internal::op::prefix_scan_op< prefix_scan_sum >, migraphx::internal::op::reduce_op< reduce_max >, migraphx::internal::op::reduce_op< reduce_mean >, migraphx::internal::op::reduce_op< reduce_min >, migraphx::internal::op::reduce_op< reduce_prod >, migraphx::internal::op::reduce_op< reduce_sum >, migraphx::internal::op::scatter< scatter_add >, migraphx::internal::op::scatter< scatter_mul >, migraphx::internal::op::scatter< scatter_none >, migraphx::internal::op::scatternd_op< scatternd_add >, migraphx::internal::op::scatternd_op< scatternd_mul >, migraphx::internal::op::scatternd_op< scatternd_none >, migraphx::internal::op::unary< abs >, migraphx::internal::op::unary< acos >, migraphx::internal::op::unary< acosh >, migraphx::internal::op::unary< asin >, migraphx::internal::op::unary< asinh >, migraphx::internal::op::unary< atan >, migraphx::internal::op::unary< atanh >, migraphx::internal::op::unary< ceil >, migraphx::internal::op::unary< convert >, migraphx::internal::op::unary< cos >, migraphx::internal::op::unary< cosh >, migraphx::internal::op::unary< erf >, migraphx::internal::op::unary< exp >, migraphx::internal::op::unary< floor >, migraphx::internal::op::unary< isnan >, migraphx::internal::op::unary< log >, migraphx::internal::op::unary< neg >, migraphx::internal::op::unary< recip >, migraphx::internal::op::unary< relu >, migraphx::internal::op::unary< round >, migraphx::internal::op::unary< rsqrt >, migraphx::internal::op::unary< sigmoid >, migraphx::internal::op::unary< sign >, migraphx::internal::op::unary< sin >, migraphx::internal::op::unary< sinh >, migraphx::internal::op::unary< sqrt >, migraphx::internal::op::unary< tan >, migraphx::internal::op::unary< tanh >, migraphx::internal::op::unary< unary_not >, migraphx::internal::op::binary< Derived >, migraphx::internal::op::prefix_scan_op< Derived >, migraphx::internal::op::reduce_op< Derived >, migraphx::internal::op::scatter< Derived >, migraphx::internal::op::scatternd_op< Derived >, migraphx::internal::op::unary< Derived >

struct outline#: #include <migraphx/op/outline.hpp>

struct pad#: #include <migraphx/op/pad.hpp>

struct pointwise#: #include <migraphx/op/pointwise.hpp>

struct pooling#: #include <migraphx/op/pooling.hpp>

struct pow : public migraphx::internal::op::binary<pow>#: #include <migraphx/op/pow.hpp>

template<class Derived> struct prefix_scan_op : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/prefix_scan_op.hpp>

struct prefix_scan_sum : public migraphx::internal::op::prefix_scan_op<prefix_scan_sum>#: #include <migraphx/op/prefix_scan_sum.hpp>

struct prelu : public migraphx::internal::op::binary<prelu>#: #include <migraphx/op/prelu.hpp>

struct quant_convolution#: #include <migraphx/op/quant_convolution.hpp>

struct quant_dot#: #include <migraphx/op/quant_dot.hpp>

struct quantizelinear#: #include <migraphx/op/quantizelinear.hpp>

struct recip : public migraphx::internal::op::unary<recip>#: #include <migraphx/op/recip.hpp>

struct reduce_max : public migraphx::internal::op::reduce_op<reduce_max>#: #include <migraphx/op/reduce_max.hpp>

struct reduce_mean : public migraphx::internal::op::reduce_op<reduce_mean>#: #include <migraphx/op/reduce_mean.hpp>

struct reduce_min : public migraphx::internal::op::reduce_op<reduce_min>#: #include <migraphx/op/reduce_min.hpp>

template<class Derived> struct reduce_op : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/reduce_op.hpp>

struct reduce_prod : public migraphx::internal::op::reduce_op<reduce_prod>#: #include <migraphx/op/reduce_prod.hpp>

struct reduce_sum : public migraphx::internal::op::reduce_op<reduce_sum>#: #include <migraphx/op/reduce_sum.hpp>

struct relu : public migraphx::internal::op::unary<relu>#: #include <migraphx/op/relu.hpp>

struct reshape#: #include <migraphx/op/reshape.hpp>

struct reverse#: #include <migraphx/op/reverse.hpp>

struct rnn#: #include <migraphx/op/rnn.hpp>

struct rnn_last_cell_output#: #include <migraphx/op/rnn_last_cell_output.hpp>

struct rnn_last_hs_output#: #include <migraphx/op/rnn_last_hs_output.hpp>

struct rnn_var_sl_last_output#: #include <migraphx/op/rnn_var_sl_last_output.hpp>

struct rnn_var_sl_shift_output#: #include <migraphx/op/rnn_variable_seq_lens.hpp>

struct rnn_var_sl_shift_sequence#: #include <migraphx/op/rnn_variable_seq_lens.hpp>

struct roialign#: #include <migraphx/op/roialign.hpp>

struct round : public migraphx::internal::op::unary<round>#: #include <migraphx/op/round.hpp>

struct rsqrt : public migraphx::internal::op::unary<rsqrt>#: #include <migraphx/op/rsqrt.hpp>

struct scalar#: #include <migraphx/op/scalar.hpp>

template<class Derived> struct scatter : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/scatter.hpp>

struct scatter_add : public migraphx::internal::op::scatter<scatter_add>#: #include <migraphx/op/scatter_add.hpp>

struct scatter_mul : public migraphx::internal::op::scatter<scatter_mul>#: #include <migraphx/op/scatter_mul.hpp>

struct scatter_none : public migraphx::internal::op::scatter<scatter_none>#: #include <migraphx/op/scatter_none.hpp>

struct scatternd_add : public migraphx::internal::op::scatternd_op<scatternd_add>#: #include <migraphx/op/scatternd_add.hpp>

struct scatternd_mul : public migraphx::internal::op::scatternd_op<scatternd_mul>#: #include <migraphx/op/scatternd_mul.hpp>

struct scatternd_none : public migraphx::internal::op::scatternd_op<scatternd_none>#: #include <migraphx/op/scatternd_none.hpp>

template<class Derived> struct scatternd_op : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/scatternd_op.hpp>

struct sigmoid : public migraphx::internal::op::unary<sigmoid>#: #include <migraphx/op/sigmoid.hpp>

struct sign : public migraphx::internal::op::unary<sign>#: #include <migraphx/op/sign.hpp>

struct sin : public migraphx::internal::op::unary<sin>#: #include <migraphx/op/sin.hpp>

struct sinh : public migraphx::internal::op::unary<sinh>#: #include <migraphx/op/sinh.hpp>

struct slice#: #include <migraphx/op/slice.hpp>

struct softmax#: #include <migraphx/op/softmax.hpp>

struct sqdiff : public migraphx::internal::op::binary<sqdiff>#: #include <migraphx/op/sqdiff.hpp>

struct sqrt : public migraphx::internal::op::unary<sqrt>#: #include <migraphx/op/sqrt.hpp>

struct squeeze#: #include <migraphx/op/squeeze.hpp>

struct step#: #include <migraphx/op/step.hpp>

struct sub : public migraphx::internal::op::binary<sub>#: #include <migraphx/op/sub.hpp>

struct tan : public migraphx::internal::op::unary<tan>#: #include <migraphx/op/tan.hpp>

struct tanh : public migraphx::internal::op::unary<tanh>#: #include <migraphx/op/tanh.hpp>

struct topk#: #include <migraphx/op/topk.hpp>

struct transpose#: #include <migraphx/op/transpose.hpp>

template<class Derived> struct unary : public migraphx::internal::op::op_name<Derived>#: #include <migraphx/op/unary.hpp>

struct unary_not : public migraphx::internal::op::unary<unary_not>#: #include <migraphx/op/unary_not.hpp>

struct undefined#: #include <migraphx/op/undefined.hpp>

struct unknown#: #include <migraphx/op/unknown.hpp>

struct unsqueeze#: #include <migraphx/op/unsqueeze.hpp>

struct where#: #include <migraphx/op/where.hpp>

struct zero#: #include <migraphx/op/reduce_op.hpp>