'으으으으' 방언

운영

mhlo.abs (mhlo::AbsOp)

복근 수술

통사론:

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)

Acos 작업

통사론:

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

operand 텐서에 대해 요소별 acos 연산을 수행하고 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))

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)

AfterAll 작업

통사론:

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

result 에 의존하는 모든 작업보다 먼저 inputs 생성하는 작업이 실행되도록 보장합니다.

참조: 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 의 요소별 AND를 수행하고 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)

아신 작전

통사론:

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

operand 텐서에 대해 요소별 asin 연산을 수행하고 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))

operand 텐서에 대해 요소별 asinh 연산을 수행하고 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))

lhs 및 rhs 텐서에 대해 요소별 atan2 연산을 수행하고 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))

operand 텐서에 대해 요소별 atanh 연산을 수행하고 result 텐서를 생성합니다.

예:

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

특성: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

인터페이스: InferShapedTypeOpInterface , InferTypeOpInterface

피연산자:

결과:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad 작업

grad_output 에서 역전파되는 BatchNormTrainingOp의 여러 입력에 대한 기울기를 계산하고 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 작업

feature_index 차원을 제외한 모든 차원에서 operand 텐서를 정규화하고 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 작업

각 feature_index 차원의 기능에 대해 배치 및 공간 차원에 걸쳐 평균과 분산을 계산하고 operand 텐서를 정규화하여 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)

비트캐스트 작업

통사론:

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

비공식적으로 이 작업은 XLA의 Broadcast와 동일한 작업을 수행합니다. 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)

케이스 작업

index 값에 따라 branches 에서 정확히 하나의 function 실행하여 출력을 생성합니다.

참조: 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 텐서의 요소별 ceil을 수행하고 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>

특성: 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)

comparison_direction 및 compare_type 에 따라 lhs 및 rhs 텐서의 요소별 비교를 수행하고 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

인터페이스: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

mhlo.composite (mhlo::CompositeOp)

복합 연산

통사론:

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

다른 StableHLO 연산으로 구성된 연산을 캡슐화하여 inputs 과 composite_attributes 받아 results 생성합니다. 연산의 의미는 분해( decomposition 속성으로 구현됩니다. composite 연산은 프로그램 의미 체계를 변경하지 않고 분해(decomposition)로 대체될 수 있습니다. 분해를 인라인으로 구현해도 동일한 연산 의미 체계를 제공하지 않는 경우 custom_call 사용하는 것이 좋습니다.

version 필드(기본값은 0 )는 합성의 의미가 변경될 때를 나타내는 데 사용됩니다.

참조: 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>

인터페이스: SymbolUserOpInterface

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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

인터페이스: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

결과:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

mhlo.convolution (mhlo::ConvolutionOp)

합성곱 연산

통사론:

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>

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

mhlo.copy (mhlo::CopyOp)

복사 작업

통사론:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: 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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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

속성:

피연산자:

결과:

mhlo.divide (mhlo::DivOp)

Div 작업

통사론:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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.

특성: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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>

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

피연산자:

결과:

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.

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

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)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

통사론:

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