'으으으으' 방언

운영

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.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 작업

프로세스 그리드의 각 프로세스 그룹 내에서 split_dimension 따라 operand 텐서의 값을 여러 부분으로 분할하고, 분할된 부분을 프로세스 간에 분산시키고, 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.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.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)

BatchNorm훈련 작업

배치 및 공간 차원 전체에서 평균과 분산을 계산하고 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)

방송 작업

이 작업은 Scablehlo에서 벗어나기 때문에 사양에 포함되지 않습니다 : https://github.com/openxla/stablehlo/issues/3

비공식적 으로이 작업은 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)

방송 운영

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 텐서의 원소 현저한 천장을 수행하고 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)

Cholesky Operation

매트릭스 배치의 Cholesky 분해를 계산합니다.

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 :: 클램프)

클램프 작동

통사론:

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)

집단 관리 운영

프로세스 그리드의 각 프로세스 그룹 내에서, 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 :: compraleop)

작업을 비교하십시오

통사론:

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)

다른 안정화 작업의 작업 (구성)을 캡슐화하고 inputs 및 composite_attributes 취하고 results 생성합니다. OP의 의미론은 decomposition 속성에 의해 구현됩니다. composite OP는 프로그램 의미를 변경하지 않고 분해로 대체 할 수 있습니다. 분해를 인라인으로 만드는 것이 동일한 OP 시맨틱을 제공하지 않는 경우 custom_call 사용하는 것이 좋습니다.

version 필드 (기본값 0에서 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)

연결 작업

주어진 인수와 동일한 순서로 dimension 차원을 따라 inputs 에서 다양한 수의 텐서를 연결하고 result 텐서를 생성합니다.

https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate를 참조하십시오

예:

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

특성 : AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

효과 : MemoryEffects::Effect{}

속성:

피연산자 :

결과:

mhlo.constant (mhlo :: constantop)

일정한 작동

일정한 value 에서 output 텐서를 생성합니다.

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>

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

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{}

속성:

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{}

속성:

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{}

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{}

속성:

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

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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{}

속성:

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.

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

예:

%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{}

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{}

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{}

속성:

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.

속성:

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{}

속성:

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{}

속성:

Operands:

결과:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

통사론:

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

Extracts element at index position of the operand tuple and produces a result .

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

예:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

Operands:

결과:

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

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

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

결과:

mhlo.imag (mhlo::ImagOp)

Imag operation

통사론:

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

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

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

예:

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

결과:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

예:

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

속성:

Operands:

결과:

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

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

예:

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

결과:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

통사론:

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

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

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

예:

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

결과:

mhlo.log (mhlo::LogOp)

Log operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

결과: