'으으으으' 방언

운영

mhlo.abs (mhlo::AbsOp)

복근 수술

통사론:

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

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

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

예:

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

특성: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
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	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

결과:

결과	설명
result	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

mhlo.acosh (mhlo::AcoshOp)

아코시 작전

통사론:

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

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

예:

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

특성: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

인터페이스: InferShapedTypeOpInterface , InferTypeOpInterface

피연산자:

피연산자	설명
operand	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

결과:

결과	설명
result	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

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	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서
rhs	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/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비트 부동 소수점 요소를 포함하는 복소수 유형의 순위가 매겨진 텐서 또는 텐서당 정수 양자화 값 또는 축당 정수 양자화 값의 순위가 매겨진 텐서 또는 토큰 또는 stablehlo 토큰
token	토큰 또는 스테이블홀 토큰

결과:

결과	설명
output	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소를 포함하는 복소수 유형의 순위가 매겨진 텐서 또는 텐서당 정수 양자화 값 또는 축당 정수 양자화 값의 순위가 매겨진 텐서 또는 토큰 또는 stablehlo 토큰

mhlo.after_all (mhlo::AfterAllOp)

AfterAll 작업

통사론:

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

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

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
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::정수 속성	값이 음수가 아닌 64비트 무부호 정수 속성
replica_groups	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널 핸들 속성	두 개의 64비트 정수 'handle'과 'type'
use_global_device_ids	::mlir::유닛 속성	단위 속성

피연산자:

피연산자	설명
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::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널 핸들 속성	두 개의 64비트 정수 'handle'과 'type'
use_global_device_ids	::mlir::유닛 속성	단위 속성

피연산자:

피연산자	설명
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::정수 속성	값이 음수가 아닌 64비트 무부호 정수 속성
concat_dimension	::mlir::정수 속성	값이 음수가 아닌 64비트 무부호 정수 속성
split_count	::mlir::정수 속성	값이 양수인 64비트 부호 없는 정수 속성
replica_groups	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널 핸들 속성	두 개의 64비트 정수 'handle'과 'type'

피연산자:

피연산자	설명
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	bool 또는 2/4/8/16/32/64비트 정수 값의 순위가 매겨진 텐서
rhs	bool 또는 2/4/8/16/32/64비트 정수 값의 순위가 매겨진 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/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	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

결과:

결과	설명
result	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone 작업

이 작업은 XLA 컴파일러에만 적용되므로 아직 사양이 없습니다.

비공식적으로, 이 연산은 비동기 계산이 끝날 때까지 차단됩니다. 비동기 계산의 최종 결과를 반환합니다.

자세한 내용은 AsyncStart에 대한 설명서를 참조하세요.

인터페이스: InferTypeOpInterface

피연산자:

피연산자	설명
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 토큰 또는 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비트 부동 소수점 요소 또는 텐서당 정수 양자화 값의 memref의 조합을 갖는 중첩 튜플 또는 축별 정수 양자화 값 또는 토큰 값의 순위가 매겨진 텐서

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::플랫심볼참조 속성	플랫 심볼 참조 속성
execution_thread	::mlir::문자열 속성	문자열 속성

피연산자:

피연산자

설명

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비트 부동 소수점 요소 또는 텐서당 정수 양자화 값의 memref의 조합을 갖는 중첩 튜플 또는 축별 정수 양자화 값 또는 토큰 값의 순위가 매겨진 텐서

결과:

결과	설명
«이름 없음»	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값 또는 토큰 또는 stablehlo 토큰 값의 순위가 매겨진 텐서의 조합을 포함하는 async_bundle

mhlo.async_update (mhlo::AsyncUpdateOp)

AsyncUpdate 작업

이 작업은 XLA 컴파일러에만 적용되므로 아직 사양이 없습니다.

비공식적으로, 이 연산은 동기화 장벽이 발생할 때까지 비동기 계산을 차단합니다. 이 연산은 해당 계산을 수행한 후 bundle 반환합니다.

자세한 내용은 AsyncStart에 대한 설명서를 참조하세요.

인터페이스: InferTypeOpInterface

피연산자:

피연산자	설명
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 토큰 값의 순위가 매겨진 텐서의 조합을 포함하는 async_bundle

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	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

결과:

결과	설명
result	32/64비트 float 요소 값을 갖는 4/6/8/16/32/64비트 float 또는 복소수 유형의 텐서

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad 작업

grad_output 에서 역전파되는 BatchNormTrainingOp의 여러 입력에 대한 기울기를 계산하고 grad_operand , grad_scale 및 grad_offset 텐서를 생성합니다.

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

예:

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
mean	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
variance	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
grad_output	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서

결과:

결과	설명
grad_operand	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서
grad_scale	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
grad_offset	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

BatchNormInference 작업

feature_index 차원을 제외한 모든 차원에서 operand 텐서를 정규화하고 result 텐서를 생성합니다.

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

예:

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
offset	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
mean	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
variance	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

BatchNormTraining 작업

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

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

예:

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

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

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서
scale	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
offset	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서

결과:

결과	설명
output	4/6/8/16/32/64비트 부동 소수점 값의 순위가 매겨진 텐서
batch_mean	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서
batch_var	4/6/8/16/32/64비트 부동 소수점 값의 1D 텐서

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	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 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비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

BitcastConvert 작업

통사론:

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

operand 텐서에 비트캐스트 연산을 수행하고 result 텐서의 유형을 사용하여 전체 operand 텐서의 비트를 재해석한 result 텐서를 생성합니다.

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 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비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

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::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 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비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

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::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/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::결과정확도 속성	단항 연산에 대해 요청된 정확도입니다.

피연산자:

피연산자	설명
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 텐서의 요소별 ceil을 수행하고 result 텐서를 생성합니다.

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
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	bool 속성

피연산자:

피연산자	설명
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	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서
max	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/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::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
channel_handle	::mlir::mhlo::채널 핸들 속성	두 개의 64비트 정수 'handle'과 'type'

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 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비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

mhlo.collective_permute (mhlo::CollectivePermuteOp)

CollectivePermute 운영

프로세스 그리드의 각 프로세스 그룹 내에서 소스 프로세스에서 대상 프로세스로 operand 텐서 값을 전송하고 result 텐서를 생성합니다.

참조: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

효과: MemoryEffects::Effect{}

속성:

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

피연산자:

피연산자	설명
operand	32/64비트 부동 소수점 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값을 갖는 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비트 정수 또는 복소수 유형의 순위가 매겨진 텐서

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::비교 방향 속성	어떤 비교 연산을 수행해야 합니까?
compare_type	::mlir::mhlo::비교유형속성	어떤 비교 유형을 사용해야 하나요?

피연산자:

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

결과:

결과	설명
«이름 없음»	bool 값의 순위가 매겨진 텐서

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	32/64비트 부동 소수점 값의 순위가 매겨진 텐서

결과:

결과	설명
result	32/64비트 부동 소수점 요소 값을 갖는 복소수 유형의 순위가 매겨진 텐서

mhlo.composite (mhlo::CompositeOp)

복합 연산

통사론:

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

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

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

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

예:

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

인터페이스: SymbolUserOpInterface

속성:

기인하다	MLIR 유형	설명
name	::mlir::문자열 속성	문자열 속성
composite_attributes	::mlir::사전 속성	명명된 속성 값의 사전
decomposition	::mlir::플랫심볼참조 속성	플랫 심볼 참조 속성
version	::mlir::정수 속성	32비트 부호 없는 정수 속성

피연산자:

피연산자	설명
inputs	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소가 있는 복합 유형 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값 또는 토큰 또는 4/6/8/16/32/64비트 부동 소수점 또는 32/64비트 부동 소수점의 순위 텐서 조합이 포함된 중첩 튜플의 순위 텐서의 가변 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서별 정수 양자화 값이 있는 복합 유형 또는 4/6/8/16/32/64비트 부동 또는 bool의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서별 정수 양자화 값 또는 순위가 있는 복합 유형 텐서 축별 정수 양자화 값 또는 토큰 값

결과:

결과	설명
«이름 없음»	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소가 있는 복합 유형 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값 또는 토큰 또는 4/6/8/16/32/64비트 부동 소수점 또는 32/64비트 부동 소수점의 순위 텐서 조합이 포함된 중첩 튜플의 순위 텐서의 가변 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서별 정수 양자화 값이 있는 복합 유형 또는 4/6/8/16/32/64비트 부동 또는 bool의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서별 정수 양자화 값 또는 순위가 있는 복합 유형 텐서 축별 정수 양자화 값 또는 토큰 값

mhlo.concatenate (mhlo::ConcatenateOp)

연결 작업

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

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

예:

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

특성: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
dimension	::mlir::정수 속성	값이 음수가 아닌 64비트 부호 없는 정수 속성

피연산자:

피연산자	설명
val	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.constant (mhlo::ConstantOp)

지속적인 작동

상수 value 에서 output 텐서를 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait , ConstantLike

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
value	::mlir::요소속성	상수 벡터/텐서 속성

결과:

결과	설명
output	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 정적인 형태의 텐서

mhlo.convert (mhlo::ConvertOp)

변환 작업

통사론:

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

operand 텐서에서 한 요소 유형에서 다른 요소 유형으로 요소별 변환을 수행하고 result 텐서를 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	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.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)

lhs 의 윈도우와 rhs 의 슬라이스 사이의 내적을 계산하고 result 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
window_strides	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
padding	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
lhs_dilation	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
rhs_dilation	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
window_reversal	::mlir::DenseElementsAttr	상수 부울 벡터/텐서 속성
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	전환 작업에 대한 차원 정보의 구조
feature_group_count	::mlir::정수 속성	값이 양수인 64비트 부호 없는 정수 속성
batch_group_count	::mlir::정수 속성	값이 양수인 64비트 부호 없는 정수 속성
precision_config	::mlir::배열 속성	정밀 구성 속성

피연산자:

피연산자	설명
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비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

결과:

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

mhlo.copy (mhlo::CopyOp)

복사 작업

통사론:

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

이 작업은 XLA 컴파일러 전용이므로 아직 사양이 없습니다.

비공식적으로 이 작업은 operand 의 복사본입니다. 작업에 첨부된 메타데이터에 따라 작업이 없는 작업과 상당히 다르게 동작할 수 있습니다.

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
cross_program_prefetch_index	::mlir::정수 속성	32비트 부호 없는 정수 속성

피연산자:

피연산자	설명
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비트 정수의 순위 텐서 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 값이 있는 복합 유형 또는 4/6/8/16/32/64비트 부동 또는 부울의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 값 또는 순위 텐서가 있는 복합 유형 축당 정수 양자화된 값 또는 토큰 값

결과:

결과	설명
result	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비트 정수의 순위 텐서 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 값이 있는 복합 유형 또는 4/6/8/16/32/64비트 부동 또는 부울의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 값 또는 순위 텐서가 있는 복합 유형 축당 정수 양자화된 값 또는 토큰 값

mhlo.cosh (mhlo::CoshOp)

코시 운영

통사론:

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

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

예:

%result = mhlo.cosh %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.cosine (mhlo::CosineOp)

코사인 연산

통사론:

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

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

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

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	단항 연산에 대해 요청된 정확도입니다.

피연산자:

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

결과:

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

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz 작업

통사론:

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

operand 텐서에서 선행 0 비트 수의 요소별 계산을 수행하고 result 텐서를 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	2/4/8/16/32/64비트 정수 값의 순위 텐서

결과:

결과	설명
result	2/4/8/16/32/64비트 정수 값의 순위 텐서

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken 작업

통사론:

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

이 작업은 StableHLO에서 벗어나는 중이므로 사양에 포함되지 않습니다: https://github.com/openxla/stablehlo/issues/3

비공식적으로 이 작업은 입력이 0인 AfterAllOp와 동일한 작업을 수행합니다. https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

예:

%output = mhlo.create_token : !mhlo.token

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

결과:

결과	설명
output	토큰

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

CrossReplicaSum 작업

이 작업은 StableHLO에서 벗어나는 중이므로 사양에 포함되지 않습니다: https://github.com/openxla/stablehlo/issues/3

비공식적으로 이 작업은 channel_id = 0 , use_global_device_ids = false 및 computation 구현 추가를 사용하여 AllReduceOp와 동일한 작업을 수행합니다. 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>

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
replica_groups	::mlir::DenseIntElementsAttr	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.custom_call (mhlo::CustomCallOp)

CustomCall 작업

통사론:

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

inputs 및 called_computations 가져와 results 생성하는 구현 정의 작업 call_target_name 캡슐화합니다.

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

인터페이스: MemoryEffectOpInterface

속성:

기인하다	MLIR 유형	설명
call_target_name	::mlir::문자열 속성	문자열 속성
has_side_effect	::mlir::BoolAttr	부울 속성
backend_config	::mlir::속성	문자열 속성 또는 명명된 속성 값의 사전
api_version	::mlir::mhlo::CustomCallApiVersionAttr	맞춤 통화 API 버전
called_computations	::mlir::배열 속성	평면 기호 참조 배열 속성
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	맞춤형 호출에 대해 원하는 일정을 지정합니다.
operand_layouts	::mlir::배열 속성	레이아웃 배열(인덱스 유형의 1D 텐서) 속성
result_layouts	::mlir::배열 속성	레이아웃 배열(인덱스 유형의 1D 텐서) 속성
output_operand_aliases	::mlir::배열 속성	CustomCall의 출력 및 피연산자에 대한 앨리어싱 속성

피연산자:

피연산자

설명

inputs

4/6/8/16/32/64비트 float 또는 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 float 요소가 있는 복합 유형의 텐서 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값 또는 4/6/8/16/32/64비트 float 또는 bool의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소가 있는 복합 유형 또는 텐서당 정수 양자화된 값 또는 토큰 또는 4/6/8/16/32/64비트 부동 또는 부울의 텐서 조합이 있는 중첩 튜플 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수가 있는 복합 유형 양자화 또는 축별 정수 양자화 값 또는 4/6/8/16/32/64비트 float 또는 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 float 요소 또는 텐서별 정수 양자화 값 또는 토큰 값을 포함하는 복합 유형의 memref

결과:

결과

설명

«이름 없음»

4/6/8/16/32/64비트 float 또는 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 float 요소가 있는 복합 유형의 텐서 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값 또는 4/6/8/16/32/64비트 float 또는 bool의 memref 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소가 있는 복합 유형 또는 텐서당 정수 양자화된 값 또는 토큰 또는 4/6/8/16/32/64비트 부동 또는 부울의 텐서 조합이 있는 중첩 튜플 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수가 있는 복합 유형 양자화 또는 축별 정수 양자화 값 또는 4/6/8/16/32/64비트 float 또는 bool 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 float 요소 또는 텐서별 정수 양자화 값 또는 토큰 값을 포함하는 복합 유형의 memref

mhlo.divide (mhlo::DivOp)

Div 작업

통사론:

operation ::= `mhlo.divide` $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#divide

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

피연산자:

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

결과:

결과	설명
result	2/4/8/16/32/64비트 정수 또는 4/6/8/16/32/64비트 부동 소수점 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

mhlo.domain (mhlo::DomainOp)

도메인 운영

이 작업은 XLA 컴파일러 전용이므로 아직 사양이 없습니다.

비공식적으로 이러한 작업은 동일한 DomainMetadata 속성을 가진 명령을 그룹화하는 데 사용됩니다. ShardingMetadata는 오늘날 동일한 장치에 대한 명령을 그룹화하는 주요 사용 사례입니다. 도메인 지침은 두 가지 주요 이점을 제공합니다.

• 도메인 전체에 걸쳐 의도치 않게 지침을 최적화하는 것을 방지합니다.
• 도메인에서 생성된 지침의 메타데이터를 자동으로 할당합니다. 도메인 지침이 없으면 각 HLO 최적화 패스는 메타데이터를 확인하고 전파해야 하며 이는 놓치기 쉽고 컴파일러에 복잡성을 추가합니다. 도메인 명령어는 두 개의 서로 다른 도메인을 연결하므로 각 도메인 명령어는 두 개의 DomainMetadata(도메인의 피연산자 측에 하나, 사용자 측에 하나)와 연결됩니다.

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
kind	::mlir::mhlo::도메인 종류 속성	HLO 도메인에 연결된 도메인 메타데이터의 종류입니다.
entry_metadata	::mlir::문자열 속성	문자열 속성
exit_metadata	::mlir::문자열 속성	문자열 속성

피연산자:

피연산자	설명
operand	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.dot (mhlo::DotOp)

도트 연산

이 작업은 StableHLO에서 벗어나는 중이므로 사양에 포함되지 않습니다: https://github.com/openxla/stablehlo/issues/3

비공식적으로 이 작업은 XLA의 Dot과 동일한 작업을 수행합니다: https://www.tensorflow.org/xla/Operation_semantics#dot

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
precision_config	::mlir::배열 속성	정밀 구성 속성

피연산자:

피연산자	설명
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비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

결과:

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

mhlo.dot_general (mhlo::DotGeneralOp)

도트일반작업

lhs 조각과 rhs 조각 사이의 내적을 계산하고 result 텐서를 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	도트의 치수 정보를 모델링하는 속성입니다.
precision_config	::mlir::배열 속성	정밀 구성 속성
algorithm	::mlir::mhlo::DotAlgorithmAttr	점 계산에 사용할 알고리즘 제약 조건을 모델링하는 속성입니다.

피연산자:

피연산자	설명
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비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

결과:

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

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim 작업

이 작업은 기능적으로 Broadcast_in_dim op와 동일하지만 결과 모양은 output_dimensions 통해 동적으로 지정됩니다.

또한 차원의 확장 동작에 대한 정적 지식을 표현하기 위해 선택적 속성을 허용합니다. 지정하지 않으면 모든 차원이 확장될 수 있는 것으로 가정됩니다. 확장되는 것으로 알려진 차원 집합과 확장되지 않는 것으로 알려진 차원 집합은 연결되지 않아야 하며 피연산자 차원의 하위 집합이어야 합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
broadcast_dimensions	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
known_expanding_dimensions	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
output_dimensions	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서

결과:

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

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv 작업

이 작업은 진행 중인 작업이므로 아직 사양에 포함되지 않았습니다: https://github.com/openxla/stablehlo/issues/8

비공식적으로 이 작업은 padding d_padding 통해 동적으로 지정된다는 점을 제외하면 ConvolutionOp와 동일한 작업을 수행합니다. https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
window_strides	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
padding	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
lhs_dilation	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
rhs_dilation	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성
window_reversal	::mlir::DenseElementsAttr	상수 부울 벡터/텐서 속성
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	전환 작업에 대한 차원 정보의 구조
feature_group_count	::mlir::정수 속성	값이 양수인 64비트 부호 없는 정수 속성
batch_group_count	::mlir::정수 속성	값이 양수인 64비트 부호 없는 정수 속성
precision_config	::mlir::배열 속성	정밀 구성 속성

피연산자:

피연산자	설명
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비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
d_padding	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.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather 작업

이 작업은 진행 중인 작업이므로 아직 사양에 포함되지 않았습니다: https://github.com/openxla/stablehlo/issues/8

비공식적으로 이 작업은 slice_sizes 동적으로 지정된다는 점을 제외하면 GatherOp와 동일한 작업을 수행합니다. 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>

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	수집을 위한 차원 정보를 모델링하는 속성
indices_are_sorted	::mlir::BoolAttr	부울 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
start_indices	2/4/8/16/32/64비트 정수 값의 순위 텐서
slice_sizes	2/4/8/16/32/64비트 정수 값의 정적인 형태의 1차원 정수 텐서

결과:

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

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota 작업

이 작업은 기능적으로 iota op와 동일하지만 결과 모양은 output_shape 통해 동적으로 지정됩니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
iota_dimension	::mlir::정수 속성	값이 음수가 아닌 64비트 부호 없는 정수 속성

피연산자:

피연산자	설명
output_shape	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

mhlo.dynamic_pad (mhlo::DynamicPadOp)

다이나믹패드 작동

통사론:

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

operand 동적으로 패딩합니다. 저급/고급/내부에 추가된 패딩 양은 입력 텐서를 통해 전달됩니다.

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
padding_value	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
edge_padding_low	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서
edge_padding_high	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서
interior_padding	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape 작업

통사론:

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

이 작업은 기능적으로 reshape op와 동일하지만 결과 모양은 output_shape 통해 동적으로 지정됩니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 텐서
output_shape	인덱스 또는 2/4/8/16/32/64비트 정수 값의 1D 텐서

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 텐서

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice 작업

동적으로 계산된 시작 인덱스를 사용하여 operand 에서 슬라이스를 추출하고 result 텐서를 생성합니다.

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
slice_sizes	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
start_indices	2/4/8/16/32/64비트 정수 값의 0D 텐서의 가변값

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice 작업

통사론:

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

start_indices 에서 시작하는 슬라이스가 update 의 값으로 업데이트된다는 점을 제외하면 operand 텐서와 동일한 result 텐서를 생성합니다.

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

피연산자:

피연산자	설명
operand	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
update	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서
start_indices	2/4/8/16/32/64비트 정수 값의 0D 텐서의 가변값

결과:

결과	설명
result	4/6/8/16/32/64비트 부동 소수점 또는 부울 또는 2/4/8/16/32/64비트 정수 또는 32/64비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

mhlo.einsum (mhlo::EinsumOp)

Einsum 작업

이 작업은 StableHLO에서 벗어나는 중이므로 사양에 포함되지 않습니다: https://github.com/openxla/stablehlo/issues/3

비공식적으로 이 작업은 TF의 einsum과 동일한 작업을 수행합니다: https://www.tensorflow.org/api_docs/python/tf/einsum

예:

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

특성: AlwaysSpeculatableImplTrait

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
einsum_config	::mlir::문자열 속성	문자열 속성

피연산자:

피연산자	설명
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비트 부동 요소 또는 텐서당 정수 양자화 또는 축당 정수 양자화 값이 있는 복합 유형의 순위 텐서

결과:

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

mhlo.erf (mhlo::ErfOp)

Erf 작동

통사론:

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

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

예:

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

특성: 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.exponential (mhlo::ExpOp)

특급작전

통사론:

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

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

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

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	단항 연산에 대해 요청된 정확도입니다.

피연산자:

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

결과:

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

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 작업

통사론:

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

operand 텐서에 대해 요소별 지수 마이너스 1 연산을 수행하고 result 텐서를 생성합니다.

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

예:

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

특성: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	단항 연산에 대해 요청된 정확도입니다.

피연산자:

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

결과:

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

mhlo.fft (mhlo::FftOp)

FFT 연산

실수 및 복소수 입력/출력에 대해 정방향 및 역 푸리에 변환을 수행합니다.

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

특성: AlwaysSpeculatableImplTrait , InferTensorType

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
fft_type	::mlir::mhlo::FftTypeAttr	XLA 고속 푸리에 변환 유형입니다.
fft_length	::mlir::DenseIntElementsAttr	64비트 부호 없는 정수 요소 속성

피연산자:

피연산자	설명
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)

Floor operation

통사론:

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

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

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

예:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

효과: MemoryEffects::Effect{}

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)

Fusion operation

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

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

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

If operation

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

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

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

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

인터페이스: 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)

효과: 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 유형	설명
infeed_config	::mlir::StringAttr	string attribute
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

Map operation

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 유형	설명
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)

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

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

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

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

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

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

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

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

인터페이스: InferTypeOpInterface

속성:

기인하다	MLIR 유형	설명
outfeed_config	::mlir::StringAttr	string 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.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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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>

인터페이스: 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)

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

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

효과: 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 유형	설명
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 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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 유형	설명
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::유닛 속성	단위 속성

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 유형	설명
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)

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

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

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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.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

인터페이스: InferTypeOpInterface

속성:

기인하다	MLIR 유형	설명
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)

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

인터페이스: InferTypeOpInterface

속성:

기인하다	MLIR 유형	설명
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

인터페이스: InferTypeOpInterface

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

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

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

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

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

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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 유형	설명
tag	::mlir::StringAttr	string 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

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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

효과: MemoryEffects::Effect{}

속성:

기인하다	MLIR 유형	설명
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)

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

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

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

인터페이스: InferTypeOpInterface

속성:

기인하다	MLIR 유형	설명
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)

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

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	설명
atol	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>

열거형

ComparisonDirection

Which comparison operation to perform.

사례:

상징	값	끈
이퀄라이저	0	이퀄라이저
북동	1	북동
GE	2	GE
지티	3	지티
르	4	르
롱	5	롱

ComparisonType

Which comparison type to use.

사례:

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

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	최신
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

사례:

상징	값	끈
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

사례:

상징	값	끈
sharding	0	sharding

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