Operators

Contents

Operators#

2024-09-30

122 min read time

Applies to Linux

operation#

struct 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 – Equivalent to running compute_shape with each shape of the argument. For a fixed shape, the returned argument will have the same shape as output. For a dynamic shape, the returned argument will be a fixed shape within the bounds set in the dynamic shape output.

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

normalize_attribute settings: Note that default options are not included as enums.

  1. use_input (default) vs. use_output: Affects the rank of the attribute. use_input -> lens.size(), use_output -> lens.size() + vec.size().

  2. use_rank (default) vs use_len: use_rank sets the max value/index of the attribute as the rank of lens. use_lens sets the max value/index as the corresponding value in lens at the axes index. Uses the dynamic_dimension.max value for dynamic shapes. Returns the original vector (no normalization) if any of dynamic_dimension[axes] are not fixed.

  3. clip_min vs. not_clip_min (default): Clip values less than the minimum to the minimum or not.

  4. include_min vs. exclude_min (default): Include or exclude the minimum value/index for range checking and clipping.

  5. clip_max vs. not_clip_max (default): Clip values greater than the maximum or not.

  6. include_max vs. exclude_max (default): Include or exclude the maximum value/index for range checking and clipping.

  7. normalize_padding: To normalize the padding to 2*(pad ndim) dimensions.

Values:

enumerator use_output#
enumerator use_len#
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>

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 allocate#
#include <migraphx/op/allocate.hpp>

Static allocate: No inputs: allocate() this.s attribute set to the static output shape of the buffer. this.s attribute can be set to a dynamic output shape; however this will allocate the maximum buffer size for that case

Dynamic allocate: One input: allocate(output_dims) output_dims are the output buffer dimensions and has a static shape. Either this.s or this.buf_type (but not both) must be set to calculate the dynamic output shape at compute time. If this.buf_type is set, the compute_shape() of allocate at compile time will have dynamic_dimensions from {0, max_int} with rank = output_dims.ndim(). If this.s is set then the compute_shape() will output this.s; this.s should be a dynamic shape.

Public Functions

inline std::string name() const#
inline shape compute_shape(const std::vector<shape> &inputs) const#
inline argument compute(const shape &output_shape, const std::vector<argument> &args) const#

Public Members

optional<shape> s#
optional<shape::type_t> buf_type#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
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 dyn_output &dyn_out, std::vector<argument> args) const#

Public Members

int64_t axis = 0#
bool select_last_index = false#

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#
bool select_last_index = false#

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 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#
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 dyn_output &dyn_out, std::vector<argument> args) const#
struct bitwise_and : public migraphx::internal::op::binary<bitwise_and>#
#include <migraphx/op/bitwise_and.hpp>

Public Functions

inline value attributes() const#
inline std::string point_function() const#
inline shape compute_shape(const std::vector<shape> &inputs) const#
inline auto apply() const#
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 (left-most to rightwards element-wise comparison) 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

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) 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 broadcast_for_dot#
#include <migraphx/op/broadcast_for_dot.hpp>

Broadcast dimensions between two tensors for the dot operator. Essentially broadcasts between two shapes for dimensions other than the last two. This operator is only needed if one of the shapes are dynamic. Example: a = shape[{1, 4}, 3, 248, 248] b = shape[248, 365] broadcast_for_dot(a, b) => shape[{1, 4}, 3, 248, 248] (no change) broadcast_for_dot(b, a) => shape[{1, 4}, 3, 248, 365]

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#
inline std::ptrdiff_t output_alias(const std::vector<shape>&) const#
struct broadcast_with_dims#
#include <migraphx/op/broadcast_with_dims.hpp>

Broadcast the input tensor to the shape defined by the values of the second input. Used as broadcast_with_dims(input_tensor, dims), where dims is a vector of integer dimensions. input_tensor must be broadcastable with dims, otherwise this operator with throw at compute. This operator can be replaced with multibroadcast(input_tensor) if the dims vector is constant.

Example: input_tensor shape: lens = {2, 3}, strides = {3, 1} dims = [4, 1, 3] output shape: lens = {4, 2, 3}, strides = {0, 3, 1}

Public Functions

inline std::string name() const#
inline shape compute_shape(const std::vector<shape> &inputs) const#
inline argument compute(const shape &output_shape, const std::vector<argument> &args) const#
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 dyn_output &dyn_out, 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 dyn_output &dyn_out, 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 dyn_output &dyn_out, 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>

Convolution operator. Does not support optimal dimensions for spatial dimensions. Returns empty optimals.

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 std::vector<std::size_t> calc_conv_lens(std::vector<std::size_t> x_lens, std::vector<std::size_t> w_lens) const#
inline shape dynamic_compute_shape(shape x_shape, shape w_shape) const#
inline shape static_compute_shape(shape x_shape, shape w_shape) const#
inline size_t kdims() const#
inline argument compute(shape output_shape, std::vector<argument> args) 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 convolution_backwards#
#include <migraphx/op/convolution_backwards.hpp>

Public Functions

inline std::string name() const#
inline void check_attribute_size() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline std::vector<std::size_t> calc_spatial_lens(std::vector<std::size_t> x_lens, std::vector<std::size_t> w_lens) const#
inline shape dynamic_compute_shape(shape x_shape, shape w_shape) const#
inline shape static_compute_shape(shape x_shape, shape w_shape) const#
inline argument compute(const dyn_output &dyn_out, 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 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 dequantizelinear#
#include <migraphx/op/dequantizelinear.hpp>

Public Functions

inline value attributes() const#
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 dimensions_of#
#include <migraphx/op/dimensions_of.hpp>

Returns the dimensions of the input argument from starting axis to ending axis. Atleast end must be set to use this operator (set end to ndim for default ONNX behavior of Shape operator) This should only be used for dynamic shapes as this can be simplified to a literal for static shapes.

Public Functions

inline std::string name() const#
inline shape compute_shape(const std::vector<shape> &inputs) const#
inline argument compute(const shape &output_shape, std::vector<argument> args) const#

Public Members

std::size_t start = 0#
std::size_t end = 0#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
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>

Matrix multiplication of two tensors.

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#
struct elu : public migraphx::internal::op::unary<elu>#
#include <migraphx/op/elu.hpp>

Public Functions

inline std::string point_op() const#
inline auto apply() 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 fill#
#include <migraphx/op/fill.hpp>

fill(default_value, output_buffer) Fill an output buffer with the given default_value. Note that if the default_value is a literal and the output_buffer has a static shape this operator can be replaced with a literal.

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#
inline std::ptrdiff_t output_alias(const std::vector<shape>&) 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(const dyn_output &dyn_out, std::vector<argument> args) 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 fmod : public migraphx::internal::op::binary<fmod>#
#include <migraphx/op/fmod.hpp>

Public Functions

inline std::string name() const#
inline value attributes() const#
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 dyn_output &dyn_out, 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 gathernd#
#include <migraphx/op/gathernd.hpp>

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#

Public Members

int batch_dims = 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 gqa_parameters#
#include <migraphx/op/group_query_attention.hpp>

Public Members

std::size_t batch_size = 0#
std::size_t sequence_length = 0#
std::size_t hidden_size = 0#
std::size_t head_size = 0#
std::size_t rotary_embedding_dim = 0#
std::size_t num_heads = 0#
std::size_t max_sequence_length = 0#
std::size_t head_stride = 0#
std::size_t seq_stride = 0#
std::size_t batch_stride = 0#
bool position_ids_use_batch = false#
std::size_t seqlen_present_kv_cache = 0#
bool past_present_share_buffer = false#
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 group_query_attention#
#include <migraphx/op/group_query_attention.hpp>

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
template<class T>
inline void run_rotary_embedding(T input, T cos_cache, T sin_cache, T output, bool interleaved, const std::size_t *pos_ids, gqa_parameters parameters) const#
template<class T>
inline void pack_v_into_rotary_qkv(gqa_parameters parameters, const T input, T output) const#
template<class T>
inline void copy_data(T destination, const T source, std::size_t n) const#
template<typename T>
inline T concat_state_chunk(const T past, const T chunk, T present, std::size_t present_buff_chunk_length, std::size_t past_buff_chunk_length, std::size_t past_chunk_length, std::size_t new_chunk_length, bool is_prompt, bool past_present_share_buffer, std::ptrdiff_t i) const#
template<class T>
inline void softmax_inplace(T score, std::size_t n, std::size_t d) const#
template<class T, class U>
inline void calculate_attention_probs(T attention_probs, T query, T key, U seqlens_k, T past_key, T present_key, shape::type_t dtype, gqa_parameters params) const#
template<class T, class U, class W>
inline void calculate_attention_score(T output, const W attention_probs, const T val, const U seqlens_k, const T past_value, T present_value, shape::type_t dtype, gqa_parameters params) const#
template<class T, class U>
inline void apply_attention(T qkv, T past_key, T past_value, T output, T present_key, T present_value, U seqlens_k, T attention_probs, gqa_parameters parameters, shape::type_t dtype) const#
inline argument compute(const shape &output_shape, std::vector<argument> args) const#

Public Members

bool do_rotary = false#
std::size_t kv_num_heads = 0#
int local_window_size = -1#
std::size_t num_heads = 1#
bool rotary_interleaved = false#
float scale = 1.0#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
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 value attributes() 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 isinf : public migraphx::internal::op::unary<isinf>#
#include <migraphx/op/isinf.hpp>

Public Functions

inline auto apply() const#
inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
struct isnan : public migraphx::internal::op::unary<isnan>#
#include <migraphx/op/isnan.hpp>

Public Functions

inline auto apply() const#
inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
struct layout : public migraphx::internal::op::unary<layout>#
#include <migraphx/op/layout.hpp>

Public Functions

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

Public Members

std::vector<int64_t> permutation#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
struct leaky_relu : public migraphx::internal::op::unary<leaky_relu>#
#include <migraphx/op/leaky_relu.hpp>

Public Functions

inline std::string point_op() const#
inline std::string name() const#
inline auto apply() 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 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 log2 : public migraphx::internal::op::unary<log2>#
#include <migraphx/op/log2.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#
std::vector<int64_t> scan_output_directions = {}#

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, const std::vector<int64_t> &scan_output_dirs, int64_t curr_iter, int64_t num_iters) 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 mod : public migraphx::internal::op::binary<mod>#
#include <migraphx/op/mod.hpp>

Public Functions

inline std::string name() const#
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>

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

Public Functions

inline std::string name() const#
inline shape compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#
inline std::ptrdiff_t output_alias(const std::vector<shape>&) const#

Public Members

std::vector<std::size_t> output_lens = {}#
std::vector<shape::dynamic_dimension> output_dyn_dims = {}#

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 dyn_output &dyn_out, 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 nearbyint : public migraphx::internal::op::unary<nearbyint>#
#include <migraphx/op/nearbyint.hpp>

Public Functions

inline auto apply() const#
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(T boxes, std::size_t box_idx) const#
inline bool suppress_by_iou(box b1, box b2, double iou_threshold) const#
template<class T>
inline std::vector<std::pair<double, int64_t>> filter_boxes_by_score(T scores_start, std::size_t num_boxes, double score_threshold) const#
template<class Output, class Boxes, class Scores>
inline std::size_t compute_nms(Output output, Boxes boxes, Scores scores, std::size_t max_output_boxes_per_class, double iou_threshold, double score_threshold) const#
inline argument compute(const shape &output_shape, std::vector<argument> args) const#

Public Members

bool center_point_box = false#
bool use_dyn_output = 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<double, 2> &operator[](std::size_t i)#
inline double area() const#

Public Members

std::array<double, 2> x#
std::array<double, 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#
struct onehot#
#include <migraphx/op/onehot.hpp>

Produces a one-hot tensor. Called with axis attribute that defaults to the last output axis Constant depth: onehot(indices, values), depth attribute must be set; Variable depth:onehot(indices, depth, values); indiciesas a N rank tensor of indices where value ison_value depthscalar with the number of classes for the one-hot dimension values[off_value, on_value] axiswhich axis to add the one-hot dimension to For axis = 0 and rank(indices) = 2: output is A[indicies[j, k], j, k] = on_value; A[i, j, k] = off_value otherwise Can be simplified to other operators whenindiceshas a static shape and depth` is constant at compile-time.

Public Functions

inline std::string name() const#
inline shape compute_shape(const std::vector<shape> &inputs) const#
inline argument compute(const shape&, std::vector<argument> args) const#

Public Members

int64_t axis = -1#
std::optional<int64_t> depth#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
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< bitwise_and >, 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_all >, migraphx::internal::op::reduce_op< reduce_any >, 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_op< scatter_add >, migraphx::internal::op::scatter_op< scatter_max >, migraphx::internal::op::scatter_op< scatter_min >, migraphx::internal::op::scatter_op< scatter_mul >, migraphx::internal::op::scatter_op< scatter_none >, migraphx::internal::op::scatternd_op< scatternd_add >, migraphx::internal::op::scatternd_op< scatternd_max >, migraphx::internal::op::scatternd_op< scatternd_min >, 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< elu >, migraphx::internal::op::unary< erf >, migraphx::internal::op::unary< exp >, migraphx::internal::op::unary< floor >, migraphx::internal::op::unary< isinf >, migraphx::internal::op::unary< isnan >, migraphx::internal::op::unary< layout >, migraphx::internal::op::unary< leaky_relu >, migraphx::internal::op::unary< log >, migraphx::internal::op::unary< log2 >, migraphx::internal::op::unary< nearbyint >, migraphx::internal::op::unary< neg >, migraphx::internal::op::unary< recip >, migraphx::internal::op::unary< relu >, 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_op< Derived >, migraphx::internal::op::scatternd_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 pack_int4#
#include <migraphx/op/pack_int4.hpp>

Public Functions

inline std::string name() const#
inline value attributes() const#
inline migraphx::shape normalize_compute_shape(std::vector<migraphx::shape> inputs) const#
inline argument compute(const shape &output_shape, std::vector<argument> args) const#

Public Members

int64_t axis = -1#

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 size_t kdims() const#
inline value attributes() const#
inline std::size_t dilate_dim(std::size_t dim, std::size_t dilation) const#
inline std::vector<std::size_t> calc_spatial_dim_out(const std::vector<std::size_t> &input_lens, std::size_t kdims) const#
inline shape normalize_compute_shape(std::vector<shape> inputs) const#
template<class Type, class Out, class In, class Op>
inline void calc_pooling(const shape &output_shape, Out &output, const In &input, const std::vector<std::size_t> &kernel_dims, const std::vector<std::size_t> &padding_vals, Op op) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#

Public Members

pooling_mode mode = {pooling_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}#
std::vector<std::size_t> dilations = {1, 1}#
bool ceil_mode = false#
int lp_order = 2#
padding_mode_t padding_mode = padding_mode_t::default_#
bool dyn_global = false#
bool count_include_pad = false#

Public Static Functions

template<class Self, class F>
static inline auto reflect(Self &self, F f)#
struct avg_pool#
#include <migraphx/op/pooling.hpp>

Public Functions

template<class T>
inline double init() const#
inline double operator()(double x, double y) const#
inline double final(double x, std::size_t y) const#
struct lpnorm_pool#
#include <migraphx/op/pooling.hpp>

Public Functions

lpnorm_pool() = delete#
inline explicit lpnorm_pool(int x)#
template<class T>
inline double init() const#
inline double operator()(double x, double y) const#
inline double final(double x, std::size_t) const#

Public Members

int p = 0#
struct max_pool#
#include <migraphx/op/pooling.hpp>

Public Functions

template<class T>
inline T init() const#
inline double operator()(double x, double y) const#
inline double final(double x, std::size_t) const#
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>

Parent struct for prefix scan operations. A prefix scan is equivalent to the C++ std::exclusive_scan or std::inclusive_scan. Given a list of numbers, a prefix scan sum op returns an equal size list of running totals of the values. Other operations besides addition can be supported by their own child ops.

Public Functions

inline value attributes() const#
inline shape normalize_compute_shape(std::vector<shape> inputs) const#
inline argument compute(const dyn_output &dyn_out, std::vector<argument> args) const#
inline aut