'мхло' Диалект

Операции

mhlo.abs (mhlo::AbsOp)

Операция ABS

Синтаксис:

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную абсолютную операцию над тензором operand и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

Пример:

%result = mhlo.abs %operand : tensor<3xi32>

Характеристики: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.acos (mhlo::AcosOp)

работа ACO

Синтаксис:

operation ::= `mhlo.acos` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию ACOS над тензором operand и выдает result тензор.

Пример:

%result = mhlo.acos %operand : tensor<2x2xf32>

Характеристики: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Операнды:

Результаты:

mhlo.acosh (mhlo::AcoshOp)

операция Акош

Синтаксис:

operation ::= `mhlo.acosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию acosh над тензором operand и выдает result тензор.

Пример:

%result = mhlo.acosh %operand : tensor<2x2xf32>

Характеристики: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Операнды:

Результаты:

mhlo.add (mhlo::AddOp)

Добавить операцию

Синтаксис:

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Выполняет поэлементное сложение двух тензоров lhs и rhs и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

Пример:

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

Характеристики: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.add_dependency (mhlo::AddDependencyOp)

операция AddDependency

Синтаксис:

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

Эта операция является внутренней для компилятора XLA, поэтому для неё пока нет спецификации.

Неформально, эта операция имеет два операнда: операнд данных и токен. Выходом операции является операнд данных. При использовании с AfterAll эта операция позволяет упорядочивать операции, не оказывающие побочных эффектов (те, которые не создают значения токенов).

Пример:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

Характеристики: AlwaysSpeculatableImplTrait

Интерфейсы: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.after_all (mhlo::AfterAllOp)

Операция «Всё после всего»

Синтаксис:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

Гарантирует, что операции, генерирующие inputs выполняются до любых операций, зависящих от result .

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Пример:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

Характеристики: AlwaysSpeculatableImplTrait

Интерфейсы: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.all_gather (mhlo::AllGatherOp)

Операция AllGather

В каждой группе процессов в сетке процессов значения тензора операндов из каждого процесса объединяются вдоль all_gather_dim , в результате чего получается тензор результатов. computation применяются отдельно для каждого операнда в operands , в результате чего получается один результат для каждого операнда.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

Пример:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

Признаки: SameOperandsAndResultElementType

Атрибуты:

Операнды:

Результаты:

mhlo.all_reduce (mhlo::AllReduceOp)

Операция AllReduce

В каждой группе процессов в сетке процессов применяется computation функции редукции к значениям тензора операндов из каждого процесса и выдается результирующий тензор. computation применяется отдельно для каждого операнда в operands , в результате чего получается один результат для каждого операнда.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Пример:

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

Характеристики: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Атрибуты:

Операнды:

Результаты:

mhlo.all_to_all (mhlo::AllToAllOp)

Операция AllToAll

В каждой группе процессов в сетке процессов значения тензора operand по split_dimension разбиваются на части, распределяются между процессами, объединяются распределенные части по concat_dimension и формируется result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

Пример:

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.and (mhlo::AndOp)

И операция

Синтаксис:

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Выполняет поэлементное И двух тензоров lhs и rhs и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

Пример:

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

Характеристики: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.asin (mhlo::AsinOp)

операция ASIN

Синтаксис:

operation ::= `mhlo.asin` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию asin над тензором operand и выдает result тензор.

Пример:

%result = mhlo.asin %operand : tensor<2x2xf32>

Характеристики: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Операнды:

Результаты:

mhlo.asinh (mhlo::AsinhOp)

Операция Асинх

Синтаксис:

operation ::= `mhlo.asinh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию asinh над тензором operand и выдает result тензор.

Пример:

%result = mhlo.asinh %operand : tensor<2x2xf32>

Характеристики: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Операнды:

Результаты:

mhlo.async_done (mhlo::AsyncDoneOp)

Операция AsyncDone

Эта операция является внутренней для компилятора XLA, поэтому для неё пока нет спецификации.

Неформально, эта операция блокируется до завершения асинхронных вычислений. Она возвращает окончательный результат асинхронных вычислений.

Для получения более подробной информации см. документацию по AsyncStart.

Интерфейсы: InferTypeOpInterface

Операнды:

Результаты:

mhlo.async_start (mhlo::AsyncStartOp)

Операция AsyncStart

Эта операция является внутренней для компилятора XLA, поэтому для неё пока нет спецификации.

Неформально говоря, эта операция запускает асинхронные вычисления.

Это используется, когда есть функции, содержащие как асинхронные ожидания (например, DMA), так и вычисления в потоке. Например, функция может состоять из вычисления, DMA, другого вычисления, второго DMA и заключительного вычисления. Это будет представлено как async_start, за которым следуют async_update и async_done. async_start выполнит первое вычисление в потоке, а затем запустит DMA. async_update будет ждать завершения DMA, если оно еще не завершено, затем выполнит второе вычисление в функции и запустит второй DMA. Наконец, async_done будет ждать завершения последнего DMA, а затем выполнит последнее необходимое вычисление в потоке и вернет результат этого заключительного вычисления.

operands передаются в вычислительный поток напрямую. called_computation — это функция, которая будет выполняться асинхронно. execution_thread — это имя потока, в котором она будет выполняться. Основной поток называется `main`. Все потоки имеют имена.

Эта функция возвращает все состояние, необходимое между асинхронными операциями. После назначения буфера возвращаемое значение представляет собой пространство, необходимое для хранения входных данных, результатов и любых временных файлов, необходимых или отредактированных асинхронной операцией.

Атрибуты:

Операнды:

Результаты:

mhlo.async_update (mhlo::AsyncUpdateOp)

Операция AsyncUpdate

Эта операция является внутренней для компилятора XLA, поэтому для неё пока нет спецификации.

Неформально, эта операция блокируется на асинхронных вычислениях до тех пор, пока не сработает барьер синхронизации. После выполнения операций она возвращает bundle .

Для получения более подробной информации см. документацию по AsyncStart.

Интерфейсы: InferTypeOpInterface

Операнды:

Результаты:

mhlo.atan2 (mhlo::Atan2Op)

операция Atan2

Синтаксис:

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Выполняет поэлементную операцию atan2 над lhs и rhs тензорами и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

Пример:

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

Характеристики: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.atanh (mhlo::AtanhOp)

Операция Атанх

Синтаксис:

operation ::= `mhlo.atanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию atanh над тензором operand и выдает result тензор.

Пример:

%result = mhlo.atanh %operand : tensor<2x2xf32>

Характеристики: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Операнды:

Результаты:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Операция BatchNormGrad

Вычисляет градиенты нескольких входных данных BatchNormTrainingOp, распространяя их обратно из grad_output , и выдает тензоры grad_operand , grad_scale и grad_offset .

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

Пример:

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Операция BatchNormInference

Нормализует тензор operand по всем измерениям, кроме измерения feature_index , и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

Пример:

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Операция BatchNormTraining

Вычисляет среднее значение и дисперсию по пакету и пространственным измерениям, нормализует тензор operand для каждой характеристики в измерении feature_index и выдает output тензоры batch_mean и batch_var .

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

Пример:

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.bitcast (mhlo::BitcastOp)

операция Bitcast

Синтаксис:

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

Эта операция является внутренней для компилятора XLA, поэтому для неё пока нет спецификации.

Неформально говоря, эта операция изменяет форму входных данных таким образом, что физическое расположение элементов остается неизменным.

Для корректного отображения «физического расположения элементов» этой операции необходима информация о компоновке, а поддержка компоновки в MHLO в настоящее время находится в стадии разработки.

Пример:

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

Характеристики: AlwaysSpeculatableImplTrait

Интерфейсы: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Операция BitcastConvert

Синтаксис:

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

Выполняет операцию приведения типов к типу в тензоре operand и создает result тензор, в котором биты всего тензора operand переинтерпретируются с использованием типа result тензора.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

Пример:

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

Характеристики: AlwaysSpeculatableImplTrait

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.broadcast (mhlo::BroadcastOp)

Ведение радиовещания

Эта операция в скором времени будет исключена из StableHLO, поэтому она не включена в спецификацию: https://github.com/openxla/stablehlo/issues/3

Неформально, эта операция делает то же самое, что и Broadcast в XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Пример:

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Работа BroadcastInDim

Расширяет размерность и/или ранг входного тензора путем дублирования данных в тензоре operand и создает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

Пример:

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

Характеристики: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Интерфейсы: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.case (mhlo::CaseOp)

Операция по расследованию дела

Формирует результат выполнения ровно одной function из branches зависящих от значения index .

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Пример:

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

Характеристики: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Интерфейсы: InferTypeOpInterface

Операнды:

Результаты:

mhlo.cbrt (mhlo::CbrtOp)

операция Cbrt

Синтаксис:

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементную операцию извлечения кубического корня из тензора operand и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Пример:

%result = mhlo.cbrt %operand : tensor<4xf32>

Характеристики: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.ceil (mhlo::CeilOp)

Работа потолка

Синтаксис:

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Выполняет поэлементное вычисление верхнего предела operand тензора и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

Пример:

%result = mhlo.ceil %operand : tensor<5xf32>

Характеристики: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.cholesky (mhlo::CholeskyOp)

Операция Холецкого

Вычисляет разложение Холецкого для группы матриц.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Пример:

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

Характеристики: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.clamp (mhlo::ClampOp)

Работа зажима

Синтаксис:

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

Функция ограничивает каждый элемент тензора operand значениями между минимальным и максимальным значениями и формирует result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Пример:

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Операнды:

Результаты:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Операция коллективного вещания

В каждой группе процессов в сетке процессов передайте значение тензора operand из исходного процесса в целевые процессы и получите result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Пример:

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

Характеристики: CompatibleOperandsAndResultType

Интерфейсы: InferShapedTypeOpInterface , InferTypeOpInterface

Атрибуты:

Операнды:

Результаты:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Операция CollectivePermute

В каждой группе процессов в сетке процессов значение тензора operand передается из исходного процесса в целевой процесс, в результате чего формируется result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Пример:

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

Характеристики: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.compare (mhlo::CompareOp)

Сравните работу

Синтаксис:

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

Выполняет поэлементное сравнение тензоров lhs и rhs в соответствии с comparison_direction и compare_type и выдает result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Пример:

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

Характеристики: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

Интерфейсы: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Эффекты: MemoryEffects::Effect{}

Атрибуты:

Операнды:

Результаты:

mhlo.complex (mhlo::ComplexOp)

Сложная операция

Синтаксис:

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

Выполняет поэлементное преобразование пары действительных и мнимых значений ( lhs и rhs ) в комплексное число и формирует result тензор.

См.: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

Пример:

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

Характеристики: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.composite (mhlo::CompositeOp)

Composite operation

Синтаксис:

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

Пример:

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

Interfaces: SymbolUserOpInterface

Attributes:

Operands:

Результаты:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate

Пример:

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

Пример:

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Результаты:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Синтаксис:

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

Пример:

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

Синтаксис:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Пример:

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.copy (mhlo::CopyOp)

Copy operation

Синтаксис:

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

Пример:

%0 = mhlo.copy %arg0 : tensor<f32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

Синтаксис:

operation ::= `mhlo.cosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosh operation on operand tensor and produces a result tensor.

Пример:

%result = mhlo.cosh %operand : tensor<2x2xf32>

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Результаты:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Синтаксис:

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

Пример:

%result = mhlo.cosine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Синтаксис:

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of leading zero bits in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

Пример:

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Синтаксис:

operation ::= `mhlo.create_token` attr-dict `:` type(results)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AfterAllOp with 0 inputs: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Пример:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Результаты:

mhlo.cross-replica-sum (mhlo::CrossReplicaSumOp)

CrossReplicaSum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Пример:

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Синтаксис:

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

Пример:

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

Attributes:

Operands:

Результаты:

mhlo.divide (mhlo::DivOp)

Div operation

Синтаксис:

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

Пример:

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.domain (mhlo::DomainOp)

Domain operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dot (mhlo::DotOp)

Dot operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

Пример:

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

Пример:

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

Пример:

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Пример:

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Пример:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

Пример:

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Синтаксис:

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Синтаксис:

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

Пример:

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

Пример:

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Синтаксис:

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

Пример:

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as TF's einsum: https://www.tensorflow.org/api_docs/python/tf/einsum

Пример:

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.erf (mhlo::ErfOp)

Erf operation

Синтаксис:

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise erf operation on operand tensor and produces a result tensor.

Пример:

%result = mhlo.erf %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Синтаксис:

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

Пример:

%result = mhlo.exponential %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Синтаксис:

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

Пример:

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

Пример:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.floor (mhlo::FloorOp)

Floor operation

Синтаксис:

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

Пример:

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Результаты:

mhlo.fusion (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

Attributes:

Operands:

Результаты:

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Пример:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

Пример:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Результаты:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Синтаксис:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)