-chlo-legalize-to-stablehlo
Legalizza dal flusso delle operazioni CHLO alle operazioni StableHLO e Shape
-shape-legalize-to-stablehlo
Legalizza le operazioni relative alla forma in StableHLO.
Un pass sperimentale che legalizza le operazioni correlate alla forma alle operazioni StableHLO.
L'unione dei calcoli di forme e dati tramite una tessera facoltativa rendere possibile all'ecosistema StableHLO di sfruttare potenzialmente pipeline di compilazione che usano operazioni StableHLO per modellare il dinamismo.
-stablehlo-aggressive-folder
Piega le operazioni StableHLO
Opzioni
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
Canonizza le operazioni StableHLO
-stablehlo-canonicalize-dynamism
Canonizza le operazioni StableHLO dinamiche in operazioni statiche.
Sostituisce le operazioni dinamiche StableHLO come DynamicReshapeOp con le controparti statiche, come ReshapeOp, se tutti gli elementi dinamici di queste operazioni sono in realtà costanti.
Ad esempio, se l'operando output_shape di DynamicReshapeOp è una costante , l'operazione può essere trasformata in ReshapeOp.
-stablehlo-convert-to-signless
Passa per trasformare l'IR in modo che sia su numeri interi senza segno.
-stablehlo-legalize-composite-to-call
Sostituisce le operazioni composte con una chiamata alla loro decomposizione
Sostituisce le operazioni composte con una chiamata alla loro decomposizione, ad esempio di seguito:
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
Diventerà:
func.call @bar(%arg0, %arg1)
Un sottoinsieme di elementi compositi può essere escluso da questa trasformazione utilizzando il metodo "tranne" flag, ad es.
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
Opzioni
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
Legalizza le operazioni deprecate in operazioni ben supportate.
Il documento RFC (#2283) relativo ai deprecazioni di Opset StableHLO v1.0 propone di rimuovere diverse operazioni ridondanti. Questa tessera consente di valutare l'impatto di queste operazioni in varie pipeline di compilazione, rendendole legali supportati a lungo termine.
Opzioni
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
Fondi il pattern (dequantizzazione, operazione in virgola mobile e quantizzazione) nell'operazione quantizzata StableHLO
Fondi il pattern (dequantizzazione, operazione in virgola mobile e quantizzazione) nell'operazione quantizzata StableHLO Nota: la tessera non elimina alcuna operazione preesistente. Ad esempio, il seguente programma
func.func @add(%arg0: tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
func.return %2 : tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
}
Diventerà:
func.func @add(%arg0: tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.abs %arg0 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
%3 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
return %2 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
}
-stablehlo-legalize-quant-to-math
Converti le operazioni quantizzate StableHLO in operazioni matematiche primitive StableHLO.
Converti i programmi StableHLO utilizzando i tipi UniformQuantized in semanticamente operazioni matematiche di numeri interi equivalenti.
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
Diventerà:
func.func @add(%arg0: tensor<i8>, %arg1: tensor<i8>) -> tensor<i8> {
%0 = stablehlo.convert %arg0 : (tensor<i8>) -> tensor<f32>
%cst = stablehlo.constant dense<0.333333343> : tensor<f32>
%1 = chlo.broadcast_multiply %0, %cst : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_0 = stablehlo.constant dense<2.000000e+00> : tensor<f32>
%2 = chlo.broadcast_add %1, %cst_0 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%3 = stablehlo.round_nearest_even %2 : tensor<f32>
%4 = stablehlo.convert %3 : (tensor<f32>) -> tensor<i32>
%5 = stablehlo.convert %arg1 : (tensor<i8>) -> tensor<f32>
%cst_1 = stablehlo.constant dense<0.666666686> : tensor<f32>
%6 = chlo.broadcast_multiply %5, %cst_1 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_2 = stablehlo.constant dense<1.33333337> : tensor<f32>
%7 = chlo.broadcast_add %6, %cst_2 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%8 = stablehlo.round_nearest_even %7 : tensor<f32>
%9 = stablehlo.convert %8 : (tensor<f32>) -> tensor<i32>
%c = stablehlo.constant dense<2> : tensor<i32>
%10 = chlo.broadcast_add %4, %9 : (tensor<i32>, tensor<i32>) -> tensor<i32>
%11 = chlo.broadcast_subtract %10, %c : (tensor<i32>, tensor<i32>) -> tensor<i32>
%c_3 = stablehlo.constant dense<-128> : tensor<i32>
%c_4 = stablehlo.constant dense<127> : tensor<i32>
%12 = stablehlo.clamp %c_3, %11, %c_4 : tensor<i32>
%13 = stablehlo.convert %12 : (tensor<i32>) -> tensor<i8>
return %13 : tensor<i8>
}
-stablehlo-legalize-quantized-op-to-qdq
Scomporre l'operazione StableHLO quantizzata in un pattern (dequantizzazione, operazione in virgola mobile e quantizzazione).
Scomporre i programmi quantizzati StableHLO utilizzando quantità/dequantizzazione uniformi operazioni. Ad esempio, il seguente programma
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
Diventerà:
func.func @add(%arg0: tensor<!quant.uniform<i8:f32, 1.000000e+00>>, %arg1: tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<f32>
%1 = stablehlo.uniform_dequantize %arg1 : (tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<f32>
%2 = stablehlo.add %0, %1 : tensor<f32>
%3 = stablehlo.uniform_quantize %2 : (tensor<f32>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
return %3 : tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
}
-stablehlo-legalize-to-vhlo
Rendi legale il progetto StableHLO a VHLO.
-stablehlo-refine-arguments
Perfeziona le forme di argomento della funzione principale.
Modifica gli argomenti della funzione principale utilizzando la firma del tipo di input. Aggrega gli argomenti in custom_call @stablehlo.shape_refinement_operand_wrapper per mantenere valido IR prima dell'esecuzione del perfezionamento della forma.
refinedTypesOption può essere utilizzato per specificare un elenco di tipi perfezionati.
Può essere specificato in MLIR con --types='tensor<...>,tensor<...>', oppure
passato al metodo pass create. L'elenco dei tipi di perfezionamento deve specificare
tipo di ogni argomento al metodo main che viene perfezionato.
Opzioni
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
Perfeziona le forme in un programma StableHLO.
Cammina nel programma StableHLO perfezionando le forme all'interno delle operazioni.
Il caso d'uso principale di questa tessera è lo sviluppo di modelli di programmazione a forme statiche. Se un programma StableHLO dalla forma dinamica ha la struttura corretta, aggiornandone i tipi di argomento dalle forme dinamiche forme statiche; l'esecuzione di questa tessera propagherà forme statiche su del programma.
-vhlo-legalize-to-stablehlo
Rendi legale VHLO in StableHLO.
-vhlo-to-version
Converti versioni di VHLO.
Opzioni
-target : The target version. Must be a version of the form #.#.# or 'current'.