Operators

Operators#

Applies to Linux

2023-06-14

21 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>

1 input version: Broadcasts a tensor from the original shape to the broadcast_lens by setting the stride of broadcasted dimensions to zero. axis attribute for a 1D input shape is the output dimension that stays the same. ex: broadcasting shape [1024] -> [4, 1024, 3] has axis = 1 For higher rank input shapes, axis is an offset parameter for the broadcasting. Such that this operator would work in the opposite direction of NumPy broadcasting. ex: broadcasting shape [2, 2] -> [2, 2, 3] with axis = 0

2 input version: Broadcast the first input 1D shape into the second input shape based on the axis parameter. Handles broadcasting a 1D static shape into a higher rank dynamic shape. broadcast_lens is not used

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 : public migraphx::internal::op::unary<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 layout : public migraphx::internal::op::unary<layout>#: #include <migraphx/op/layout.hpp>

struct leaky_relu : public migraphx::internal::op::unary<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>

Broadcast multiple dimensions between two tensors. Two versions of this operator: one input and two inputs. One input version uses output_lens attribute and broadcasts to it. Two inputs version broadcasts both inputs to the common shape at evaluation time.

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.

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>

Adds dimensions to a tensor based on the axes attribute. axes are based on the number of output shape dimensions and should not contain duplicates. steps are for modifying dimensions added to the middle of the original shape. Each step must be a factor of the original dimension. ex: unsqueeze(shape = [3, 4, 10], axes = [2, 4, 5], steps = [2]) -> shape = [3, 4, 2, 5, 1, 1] Dynamic shape version does not handle steps.

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

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

Operators

Contents

Operators#

operation#

operators#