'으으으으' 방언

운영

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

피연산자:

피연산자	설명
operand	2/4/8/16/32/64비트 부호 없는 정수 또는 4/6/8/16/32/64비트 부동 소수점 또는 32/64비트 부동 소수점 요소를 가진 복소수 유형의 순위 텐서 또는 2/4/8/16/32비트 균일 양자화된 부호 있는 정수 또는 2/4/8/16/32비트 축별 균일 양자화된 부호 있는 정수 또는 2/4/8/16/32비트 균일 양자화된 부호 없는 정수 또는 2/4/8/16/32비트 축별 균일 양자화된 부호 없는 정수 값

결과:

결과	설명
result	2/4/8/16/32/64비트 부호 없는 정수 또는 4/6/8/16/32/64비트 부동 소수점 또는 2/4/8/16/32비트 균일 양자화된 부호 있는 정수 또는 2/4/8/16/32비트 축별 균일 양자화된 부호 있는 정수 또는 2/4/8/16/32비트 균일 양자화된 부호 없는 정수 또는 2/4/8/16/32비트 축별 균일 양자화된 부호 없는 정수 값의 순위 텐서

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

mhlo.acosh (mhlo::AcoshOp)

아코쉬 작전

통사론:

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

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

예:

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

특성: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

인터페이스: InferShapedTypeOpInterface , InferTypeOpInterface

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

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

피연산자:

피연산자	설명
lhs	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값
rhs	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 또는 텐서별 정수 양자화 값, 또는 축별 정수 양자화 값을 갖는 순위 텐서, 또는 토큰 또는 스테이블로 토큰
token	토큰 또는 스테이블로 토큰

결과:

결과	설명
output	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 또는 텐서별 정수 양자화 값, 또는 축별 정수 양자화 값을 갖는 순위 텐서, 또는 토큰 또는 스테이블로 토큰

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

피연산자:

피연산자	설명
inputs	토큰의 가변 인자

결과:

결과	설명
result	토큰

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

속성:

기인하다	MLIR 유형	설명
all_gather_dim	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성
replica_groups	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널핸들어트	두 개의 64비트 정수 '핸들'과 '유형'
use_global_device_ids	::mlir::UnitAttr	단위 속성

피연산자:

피연산자	설명
operands	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
replica_groups	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널핸들어트	두 개의 64비트 정수 '핸들'과 '유형'
use_global_device_ids	::mlir::UnitAttr	단위 속성

피연산자:

피연산자	설명
operands	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
split_dimension	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성
concat_dimension	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성
split_count	::mlir::IntegerAttr	값이 양수인 64비트 부호 없는 정수 속성
replica_groups	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널핸들어트	두 개의 64비트 정수 '핸들'과 '유형'

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

피연산자:

피연산자	설명
lhs	부울 또는 2/4/8/16/32/64비트 정수 값으로 구성된 순위 텐서
rhs	부울 또는 2/4/8/16/32/64비트 정수 값으로 구성된 순위 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone 작업

이 작업은 XLA 컴파일러만의 고유한 기능이므로 아직 명세가 없습니다.

비공식적으로 말하면, 이 연산은 비동기 계산이 완료될 때까지 대기합니다. 그리고 비동기 계산의 최종 결과를 반환합니다.

자세한 내용은 AsyncStart 설명서를 참조하십시오.

인터페이스: InferTypeOpInterface

피연산자:

피연산자	설명
bundle	async_bundle은 4/6/8/16/32/64비트 부동 소수점 또는 부울, 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 텐서별 정수 양자화 값, 축별 정수 양자화 값, 토큰 또는 stablehlo 토큰 값의 모든 조합과 함께 사용할 수 있습니다.

결과:

결과

설명

«이름 없는»

4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위 텐서의 가변 인자(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값 또는 축별 정수 양자화 값 또는 토큰 또는 stablehlo 토큰 또는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값의 조합을 포함하는 중첩 튜플 또는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 메모리 참조(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값 또는 순위 텐서 축별 정수 양자화 값 또는 토큰 값으로 이루어진 텐서

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"이라고 합니다. 모든 스레드에는 이름이 있습니다.

이 함수는 비동기 작업 간에 필요한 모든 상태 정보를 반환합니다. 버퍼 할당 후, 반환 값은 입력, 결과, 그리고 비동기 작업에서 필요하거나 편집되는 임시 저장 공간을 저장하는 데 필요한 공간을 나타냅니다.

속성:

기인하다	MLIR 유형	설명
called_computation	::mlir::FlatSymbolRefAttr	평면 기호 참조 속성
execution_thread	::mlir::StringAttr	문자열 속성

피연산자:

피연산자

설명

inputs

4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위 텐서의 가변 인자(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값 또는 축별 정수 양자화 값 또는 토큰 또는 stablehlo 토큰 또는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값의 조합을 포함하는 중첩 튜플 또는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 메모리 참조(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 값 또는 순위 텐서 축별 정수 양자화 값 또는 토큰 값으로 이루어진 텐서

결과:

결과	설명
«이름 없는»	async_bundle은 4/6/8/16/32/64비트 부동 소수점 또는 부울, 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 텐서별 정수 양자화 값, 축별 정수 양자화 값, 토큰 또는 stablehlo 토큰 값의 모든 조합과 함께 사용할 수 있습니다.

mhlo.async_update (mhlo::AsyncUpdateOp)

비동기 업데이트 작업

이 작업은 XLA 컴파일러만의 고유한 기능이므로 아직 명세가 없습니다.

비공식적으로, 이 작업은 동기 장벽이 발생할 때까지 비동기 계산을 차단합니다. 이 작업은 bundle 처리한 후 반환합니다.

자세한 내용은 AsyncStart 설명서를 참조하십시오.

인터페이스: InferTypeOpInterface

피연산자:

피연산자	설명
bundle	async_bundle은 4/6/8/16/32/64비트 부동 소수점 또는 부울, 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 텐서별 정수 양자화 값, 축별 정수 양자화 값, 토큰 또는 stablehlo 토큰 값의 모든 조합과 함께 사용할 수 있습니다.

결과:

결과	설명
«이름 없는»	async_bundle은 4/6/8/16/32/64비트 부동 소수점 또는 부울, 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위 텐서, 텐서별 정수 양자화 값, 축별 정수 양자화 값, 토큰 또는 stablehlo 토큰 값의 모든 조합과 함께 사용할 수 있습니다.

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

피연산자:

피연산자	설명
lhs	32/64비트 부동 소수점 요소 또는 텐서별 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서
rhs	32/64비트 부동 소수점 요소 또는 텐서별 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 또는 텐서별 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 텐서이며, 요소 값은 32/64비트 부동 소수점입니다.

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

속성:

기인하다	MLIR 유형	설명
epsilon	::mlir::플로트어트	32비트 부동소수점 속성
feature_index	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
mean	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
variance	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
grad_output	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서

결과:

결과	설명
grad_operand	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서
grad_scale	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
grad_offset	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

배치 정규화 추론 연산

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

속성:

기인하다	MLIR 유형	설명
epsilon	::mlir::플로트어트	32비트 부동소수점 속성
feature_index	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
offset	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
mean	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
variance	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

배치정규화 학습 작업

feature_index 차원의 각 특징에 대해 배치 및 공간 차원에 걸쳐 평균과 분산을 계산하고 operand 텐서를 정규화한 다음, batch_mean 및 batch_var 텐서를 output 합니다.

자세한 내용은 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{}

속성:

기인하다	MLIR 유형	설명
epsilon	::mlir::플로트어트	32비트 부동소수점 속성
feature_index	::mlir::IntegerAttr	값이 음수가 아닌 64비트 부호 없는 정수 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
offset	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서

결과:

결과	설명
output	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 순위 텐서
batch_mean	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서
batch_var	4/6/8/16/32/64비트 부동 소수점 값으로 이루어진 1차원 텐서

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

BitcastConvert 작업

통사론:

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

operand 텐서에 비트캐스트 연산을 수행하고, operand 텐서 전체의 비트를 result 텐서의 타입으로 재해석한 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{}

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
broadcast_sizes	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
broadcast_dimensions	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 정적인 형태 또는 단일 유한 차원 텐서 (32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

피연산자:

피연산자	설명
index	32비트 부호 없는 정수 값의 텐서

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 갖는 복소수 유형의 순위 텐서 또는 텐서별 정수 양자화 값 또는 축별 정수 양자화 값의 순위 텐서 또는 토큰

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

속성:

기인하다	MLIR 유형	설명
result_accuracy	::mlir::mhlo::결과정확도Attr	단항 연산에 요구되는 정확도.

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서별 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 또는 텐서별 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 텐서별 정수 양자화 값으로 구성된 순위 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 텐서별 정수 양자화 값으로 구성된 순위 텐서

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

속성:

기인하다	MLIR 유형	설명
lower	::mlir::BoolAttr	부울 속성

피연산자:

피연산자	설명
a	32비트/64비트 부동 소수점 요소 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

결과:

결과	설명
«이름 없는»	32비트/64비트 부동 소수점 요소 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 복소수 유형의 순위 텐서

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

피연산자:

피연산자	설명
min	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값
max	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
replica_groups	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널핸들어트	두 개의 64비트 정수 '핸들'과 '유형'

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
source_target_pairs	::mlir::밀도인터플랜트 속성	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널핸들어트	두 개의 64비트 정수 '핸들'과 '유형'

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

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

속성:

기인하다	MLIR 유형	설명
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	어떤 비교 연산을 수행할 것인가?
compare_type	::mlir::mhlo::비교유형속성	어떤 비교 유형을 사용해야 할까요?

피연산자:

피연산자	설명
lhs	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값
rhs	4/6/8/16/32/64비트 부동 소수점 또는 부울, 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서(32/64비트 부동 소수점 요소 포함) 또는 텐서별 정수 양자화 또는 축별 정수 양자화 값

결과:

결과	설명
«이름 없는»	부울 값의 순위가 매겨진 텐서

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

피연산자:

피연산자	설명
lhs	32/64비트 부동 소수점 값으로 이루어진 순위 텐서
rhs	ranked tensor of 32/64-bit float values

결과:

결과	설명
result	ranked tensor of complex type with 32/64-bit float elements values

mhlo.composite (mhlo::CompositeOp)

복합 연산

통사론:

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

속성:

기인하다	MLIR Type	설명
name	::mlir::StringAttr	문자열 속성
composite_attributes	::mlir::DictionaryAttr	dictionary of named attribute values
decomposition	::mlir::FlatSymbolRefAttr	flat symbol reference attribute
version	::mlir::IntegerAttr	32-bit signless integer attribute

Operands:

피연산자

설명

inputs

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

결과:

결과

설명

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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

속성:

기인하다	MLIR Type	설명
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

피연산자	설명
val	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
value	::mlir::ElementsAttr	constant vector/tensor attribute

결과:

결과	설명
output	statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
lhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
rhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_reversal	::mlir::DenseElementsAttr	constant boolean vector/tensor attribute
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Structure of dimension information for conv op
feature_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
batch_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
cross_program_prefetch_index	::mlir::IntegerAttr	32-bit signless integer attribute

Operands:

피연산자

설명

operand

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

결과:

결과

설명

result

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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:

피연산자	설명
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

결과:

결과	설명
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

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

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

피연산자	설명
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer values

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

결과:

결과	설명
output	토큰

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

속성:

기인하다	MLIR Type	설명
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
call_target_name	::mlir::StringAttr	문자열 속성
has_side_effect	::mlir::BoolAttr	bool attribute
backend_config	::mlir::Attribute	string attribute or dictionary of named attribute values
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Custom call API version
called_computations	::mlir::ArrayAttr	flat symbol ref array attribute
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Specifies the desired schedule for the custom-call.
operand_layouts	::mlir::ArrayAttr	Array of layout (1D tensor of index type) attributes
result_layouts	::mlir::ArrayAttr	Array of layout (1D tensor of index type) attributes
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of CustomCall

Operands:

피연산자

설명

inputs

variadic of tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or token or nested tuple with any combination of tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or token values

결과:

결과

설명

«unnamed»

variadic of tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or token or nested tuple with any combination of tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or token values

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:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
kind	::mlir::mhlo::DomainKindAttr	Kind of domain metatdata attached to an HLO domain.
entry_metadata	::mlir::StringAttr	문자열 속성
exit_metadata	::mlir::StringAttr	문자열 속성

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

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

속성:

기인하다	MLIR Type	설명
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute
algorithm	::mlir::mhlo::DotAlgorithmAttr	Attribute that models the algorithm constraints to use for computing dot.

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
broadcast_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
known_expanding_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
output_dimensions	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
lhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
rhs_dilation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_reversal	::mlir::DenseElementsAttr	constant boolean vector/tensor attribute
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Structure of dimension information for conv op
feature_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
batch_group_count	::mlir::IntegerAttr	64-bit signless integer attribute whose value is positive
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
d_padding	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values
slice_sizes	statically shaped 1-dimensional integer tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

피연산자	설명
output_shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
edge_padding_low	1D tensor of index or 2/4/8/16/32/64-bit integer values
edge_padding_high	1D tensor of index or 2/4/8/16/32/64-bit integer values
interior_padding	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

피연산자	설명
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
output_shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	variadic of 0D tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
update	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	variadic of 0D tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
einsum_config	::mlir::StringAttr	문자열 속성

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

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

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

속성:

기인하다	MLIR Type	설명
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.floor (mhlo::FloorOp)

바닥 운영

통사론:

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

mhlo.fusion (mhlo::FusionOp)

핵융합 작동

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.

속성:

기인하다	MLIR Type	설명
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

결과:

결과

설명

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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

속성:

기인하다	MLIR Type	설명
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

속성:

기인하다	MLIR Type	설명
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	tensor of 32-bit signless integer values

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

속성:

기인하다	MLIR Type	설명
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

피연산자

설명

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

결과:

결과

설명

«unnamed»

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.if (mhlo::IfOp)

만약 작동한다면

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:

피연산자	설명
pred	ranked tensor of bool values

결과:

결과	설명
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

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:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

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)

속성:

기인하다	MLIR Type	설명
infeed_config	::mlir::StringAttr	문자열 속성
layout	::mlir::ArrayAttr	array attribute

Operands:

피연산자	설명
token	토큰

결과:

결과

설명

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

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

속성:

기인하다	MLIR Type	설명
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

결과:

결과	설명
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

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:

피연산자	설명
x	ranked tensor of 4/6/8/16/32/64-bit float values

결과:

결과	설명
y	ranked tensor of bool values

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

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

통사론:

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

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

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

예:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

지도 작업

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

예:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

통사론:

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

예:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

통사론:

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

예:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

통사론:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
shapes	variadic of 1D tensor of index values

결과:

결과	설명
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

통사론:

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

예:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

통사론:

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

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

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

예:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

통사론:

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

예:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

통사론:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

예:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

결과:

결과	설명
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

통사론:

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

예:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

예:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
outfeed_config	::mlir::StringAttr	문자열 속성

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	토큰

결과:

결과	설명
«unnamed»	토큰

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

예:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

통사론:

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

Produces partition_id of the current process.

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

예:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

결과:

결과	설명
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

통사론:

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

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

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

예:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

통사론:

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

예:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

피연산자	설명
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

통사론:

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

예:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

예:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

속성:

기인하다	MLIR Type	설명
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
token	토큰

결과:

결과

설명

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

예:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

통사론:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

예:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float values

결과:

결과	설명
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

예:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

속성:

기인하다	MLIR Type	설명
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

예:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

통사론:

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

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

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

예:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

통사론:

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

Produces replica_id of the current process.

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

예:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

결과:

결과	설명
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

통사론:

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

Performs reshape of operand tensor to a result tensor.

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

예:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

예:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

피연산자	설명
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

예:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

피연산자	설명
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

결과:

결과	설명
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

통사론:

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

통사론:

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

통사론:

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scan (mhlo::ScanOp)

Scan operation

Applies a reduction function body to inputs and inits along the dimension and produces results (comprising outputs and carries ).

If is_reverse is true, the scan is performed in reverse order. is_associative indicates whether the reduction function is associative.

See: https://www.tensorflow.org/xla/operation_semantics#scan

Traits: AttrSizedOperandSegments , InferTensorType , RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
is_reverse	::mlir::BoolAttr	bool attribute
is_associative	::mlir::mhlo::AssociativityAttr	Associativity of the scan operation.

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
inits	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
results	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

예:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

통사론:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

예:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

예:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

예:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	토큰

결과:

결과	설명
«unnamed»	토큰

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

예:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

통사론:

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

예:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

통사론:

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

예:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

통사론:

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

예:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

통사론:

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

Returns the sign of the operand element-wise and produces a result tensor.

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

예:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

통사론:

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

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

예:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

피연산자	설명
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

결과:

결과	설명
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

예:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

예:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

피연산자	설명
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

통사론:

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

예:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

통사론:

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

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

Informally, this operation returns Tan(operand) element-wise.

예:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

통사론:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

예:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

예:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

통사론:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

예:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

속성:

기인하다	MLIR Type	설명
tag	::mlir::StringAttr	문자열 속성

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

예:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

예:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

속성:

기인하다	MLIR Type	설명
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

피연산자	설명
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

결과:

결과	설명
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

통사론:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

예:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자

설명

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과

설명

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

통사론:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

예:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

통사론:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

예:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

결과:

결과	설명
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

예:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

피연산자

설명

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

결과:

결과

설명

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

통사론:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

속성:

기인하다	MLIR Type	설명
delta	::mlir::IntegerAttr	64-bit signless integer attribute

결과:

결과	설명
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

통사론:

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

예:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

피연산자	설명
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

결과:

결과	설명
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

속성

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

매개변수:

매개변수	C++ type	설명
argTupleIndices	::llvm::ArrayRef<int64_t>	차원
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	차원
isMustAlias	bool

AssociativityAttr

Associativity of the scan operation.

통사론:

#mhlo.associativity<
  ::mlir::mhlo::Associativity   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::Associativity	an enum of type Associativity

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

통사론:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

매개변수:

매개변수	C++ type	설명
핸들	int64_t
유형	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

통사론:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

통사론:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

매개변수:

매개변수	C++ type	설명
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	차원
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	차원
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	차원

CrossProgramPrefetchAttr

Argument that is prefetched from another program

통사론:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

예를 들어,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

매개변수:

매개변수	C++ type	설명
매개변수	int64_t
지수	::llvm::ArrayRef<int64_t>	차원
오프셋	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

통사론:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

통사론:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

통사론:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

통사론:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

매개변수:

매개변수	C++ type	설명
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

매개변수:

매개변수	C++ type	설명
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	차원
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	차원
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	차원
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	차원

FftTypeAttr

XLA fast fourier transform type.

통사론:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

통사론:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

매개변수:

매개변수	C++ type	설명
offsetDims	::llvm::ArrayRef<int64_t>	차원
collapsedSliceDims	::llvm::ArrayRef<int64_t>	차원
operandBatchingDims	::llvm::ArrayRef<int64_t>	차원
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	차원
startIndexMap	::llvm::ArrayRef<int64_t>	차원
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

통사론:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

매개변수:

매개변수	C++ type	설명
outputTupleIndices	::llvm::ArrayRef<int64_t>	차원
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	차원

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

통사론:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

매개변수:

매개변수	C++ type	설명
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	차원
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	차원

ResultAccuracyAttr

The requested accuracy for unary ops.

매개변수:

매개변수	C++ type	설명
아톨	APFloat
rtol	APFloat
ulps	int64_t
방법	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

통사론:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

통사론:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

통사론:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

매개변수:

매개변수	C++ type	설명
updateWindowDims	::llvm::ArrayRef<int64_t>	차원
insertedWindowDims	::llvm::ArrayRef<int64_t>	차원
inputBatchingDims	::llvm::ArrayRef<int64_t>	차원
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	차원
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	차원
indexVectorDim	int64_t

TransposeAttr

Transpose options

통사론:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

매개변수:

매개변수	C++ type	설명
값	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

통사론:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

매개변수:

매개변수	C++ type	설명
범위	::llvm::ArrayRef<int64_t>

유형

AsyncBundleType

Opaque collection of other types

통사론:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

매개변수:

매개변수	C++ type	설명
유형	::llvm::ArrayRef<Type>

열거형

연관성

Associativity of the scan operation.

사례:

상징	값	끈
아마도	0	아마도
진실	1	진실
거짓	2	거짓

ComparisonDirection

Which comparison operation to perform.

사례:

상징	값	끈
EQ	0	EQ
북동쪽	1	북동쪽
GE	2	GE
GT	3	GT
LE	4	LE
LT	5	LT

ComparisonType

Which comparison type to use.

사례:

상징	값	끈
NOTYPE	0	NOTYPE
뜨다	1	뜨다
TOTALORDER	2	TOTALORDER
서명됨	3	서명됨
서명 없음	4	서명 없음

CustomCallApiVersion

Custom call API version

사례:

상징	값	끈
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

사례:

상징	값	끈
없음	0	없음
최신	1	최신
가장 이른	2	가장 이른

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

사례:

상징	값	끈
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

사례:

상징	값	끈
분할	0	분할

FftType

XLA fast fourier transform type.

사례:

상징	값	끈
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

사례:

상징	값	끈
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

정도

XLA precision for an operand. Has backend specific meaning.

사례:

상징	값	끈
기본	0	기본
높은	1	높은
제일 높은	2	제일 높은

ResultAccuracyMode

XLA result accuracy mode.

사례:

상징	값	끈
기본	0	기본
제일 높은	1	제일 높은
용인	2	용인

RngAlgorithm

XLA PRNG algorithm to be used.

사례:

상징	값	끈
기본	0	기본
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

사례:

상징	값	끈
제복	1	제복
정상	2	정상

바꾸어 놓다

Transpose options

사례:

상징	값	끈
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
바꾸어 놓다	2	바꾸어 놓다
ADJOINT	3	ADJOINT