OpenXLA Project

Questa pagina è stata tradotta dall'API Cloud Translation.

`-chlo-legalize-to-stablehlo`

Legalizza il flusso delle operazioni CHLO in operazioni StableHLO e Shape

`-shape-legalize-to-stablehlo`

Legalizza le operazioni relative alle forme in StableHLO.

Un passaggio sperimentale che legalizza le operazioni relative alla forma per le operazioni StableHLO.

L'unione dei calcoli delle forme e dei dati tramite un passaggio facoltativo consentirà all'ecosistema StableHLO di sfruttare potenzialmente le pipeline di compilazione che utilizzano le operazioni StableHLO per modellare il dinamismo.

`-stablehlo-aggressive-folder`

Combina le operazioni StableHLO

Opzioni

-fold-float : Allow for potentially lossy computations using float type.

`-stablehlo-aggressive-simplification`

Esegue la canonizzazione delle operazioni StableHLO

`-stablehlo-canonicalize-dynamism`

Esegue la canonizzazione delle operazioni StableHLO dinamiche in operazioni statiche.

Sostituisce le operazioni StableHLO dinamiche come DynamicReshapeOp con le corrispondenti operazioni statiche come DynamicReshapeOp con ReshapeOp o DynamicBroadcastInDim con BroadcastInDim se tutti gli elementi dinamici di queste operazioni sono effettivamente costanti.

  %c = stablehlo.constant dense<16> : tensor<1xi32>
  %0 = stablehlo.dynamic_broadcast_in_dim %cst, %c, dims = [] : (tensor<f32>, tensor<1xi32>) -> tensor<16xf32>

  ==>

  %0 = stablehlo.broadcast_in_dim %cst, dims = [] : (tensor<f32>) -> tensor<16xf32>

`-stablehlo-compatibility-expander`

Expander di compatibilità per le operazioni StableHLO.

Le operazioni StableHLO ricevono aggiornamenti o vengono introdotte nuove operazioni nelle versioni più recenti. Questo passaggio di attivazione amplia la compatibilità con le versioni precedenti di StableHLO scomponendo le operazioni StableHLO più recenti in operazioni equivalenti supportate da queste versioni precedenti.

Perché si tratta di una tessera ad attivazione facoltativa?

A volte, i miglioramenti delle operazioni StableHLO vengono utilizzati per semplificare notevolmente la gestione di determinati pattern comuni nell'ecosistema OpenXLA. Sono inclusi elementi come TanOp, che ha un'elevata compatibilità con framework e compilatori, nonché le dimensioni di raggruppamento gather/scatter, che possono essere rappresentate utilizzando i segmenti, ma rendono molto più difficile lo sharding. Per questa categoria di nuove funzionalità, non offriamo il downgrade automatico, poiché potrebbero essere eliminate informazioni importanti utilizzate nelle ottimizzazioni successive. Questo passaggio può essere utilizzato per espandere queste operazioni in base a una versione di destinazione per massimizzare la compatibilità a spese di una compilazione potenzialmente meno ottimale.

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %1 = stablehlo.tan %arg0 : tensor<4xf64>
  func.return %1 : tensor<4xf64>
}

==>

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %0 = stablehlo.sine %arg0 : tensor<4xf64>
  %1 = stablehlo.cosine %arg0 : tensor<4xf64>
  %2 = stablehlo.divide %0, %1 : tensor<4xf64>
  return %2 : tensor<4xf64>
}

Opzioni

-target : The target version. Must be a version of the form #.#.#.

`-stablehlo-convert-to-signless`

Passa per trasformare l'IR in numeri interi senza segno.

`-stablehlo-legalize-composite-to-call`

Sostituisci le operazioni composite con una chiamata alla loro decomposizione.

Sostituisce le operazioni composite con una chiamata alla loro decomposizione, ad esempio la seguente:

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 compositi può essere escluso da questa trasformazione utilizzando il flag "except", ad esempio:

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 ritirate in modo che siano supportate.

L'RFC relativo al ritiro degli opset di StableHLO 1.0 (#2283) propone di rimuovere diverse operazioni ridondanti. Questo passaggio consente di valutare l'impatto di queste rimozione di op nelle varie pipeline di compilazione legalizzandole rispetto alle loro controparti supportate a lungo termine.

Opzioni

-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.

`-stablehlo-legalize-qdq-to-quantized-op`

Unisci il pattern (dequantizzazione, operazione in virgola mobile e quantizzazione) nell'operazione quantizzata StableHLO

Unisci il pattern (dequantizzazione, operazione in virgola mobile e quantizzazione) in un'operazione quantizzata StableHLO Nota: il passaggio non elimina le operazioni esistenti. 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`

Esegui la conversione dalle operazioni quantizzate di StableHLO alle operazioni matematiche primitive di StableHLO.

Converti i programmi StableHLO che utilizzano tipi UniformQuantized in operazioni matematiche con numeri interi semanticamente 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`

Decomponi l'operazione quantizzata StableHLO nel pattern (dequantizzazione, operazione in virgola mobile e quantizzazione).

Decomponi i programmi quantizzati StableHLO utilizzando operazioni di quantizzazione/dequantizzazione uniformi. 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`

Legittimare StableHLO per VHLO.

`-stablehlo-refine-arguments`

Perfeziona le forme degli argomenti della funzione principale.

Modifica gli argomenti della funzione principale utilizzando la firma del tipo di input. Inserisce gli argomenti in custom_call @stablehlo.shape_refinement_operand_wrapper per mantenere valido l'IR prima dell'esecuzione del perfezionamento della forma.

func.func public @main(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  ...
}

==>

func.func public @main(%arg0: tensor<16xf32>) -> tensor<?xf32> {
  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
    : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  ...

refinedTypesOption può essere utilizzato per specificare un elenco di tipi perfezionati. Questo può essere specificato in MLIR con --types='tensor<...>,tensor<...>' o passato al metodo di creazione della tessera. L'elenco dei tipi di perfezionamento deve specificare il tipo di ogni argomento del metodo main da perfezionare.

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.

Illustra un programma StableHLO che perfeziona le forme all'interno delle operazioni.

Il caso d'uso principale di questo passaggio è specializzare i programmi con forme dinamiche in forme statiche. Se un programma StableHLO con forme dinamiche ha la struttura corretta, l'aggiornamento dei tipi di argomenti dalle forme dinamiche alle forme statiche ed l'esecuzione di questo passaggio propagheranno le forme statiche nel programma.

Questo passaggio rimuove custom_call @shape_refinement_operand_wrapper sostituendo gli utilizzi del risultato direttamente con l'operando e propaga le forme statiche in tutto il programma.

  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
      : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  %1 = stablehlo.add %0, %0 : tensor<?xf32>

  ==>

  %1 = stablehlo.add %arg0, %arg0 : tensor<16xf32>

I moduli validi per il perfezionamento della forma devono avere le seguenti proprietà:

Tutte le forme dinamiche dipendono solo dalle forme di input (nessuna dipendenza della forma dai contenuti dell'array di input). Le operazioni che dipendono in modo transitivo solo dalle forme di input (ad es. come specificato da stablehlo.get_dimension_size) o da costanti globali come i valori risolti degli interi simbolici (ad es. tensore : A = 5) sono chiamate operazioni dimension. Tutti i valori delle dimensioni possono essere risolti in costanti tramite la rilettura delle costanti interprocedurali.
Le funzioni intermedie possono accettare una serie di argomenti token (di tipo !stablehlo.token) all'inizio dell'elenco degli argomenti, seguiti da alcuni argumenti costanti globali che sono scalari interi costanti, come i valori risolti degli interi simbolici (ad es. tensore : A = 5).
Alcune funzioni intermedie possono restituire calcoli su costanti globali, ovvero floordiv sui valori di symint. Queste funzioni sono indicate dal fatto che restituiscono solo valori costanti dopo il perfezionamento. Queste funzioni sono incorporate.
Tutte le chiamate a una singola funzione risolvono le stesse forme di argomento e non vengono eseguite chiamate di funzioni ricorsive / co-ricorsive. ### -vhlo-legalize-to-stablehlo

Legittima VHLO in StableHLO.

`-vhlo-to-version`

Eseguire la conversione tra le versioni di VHLO.

Opzioni

-target : The target version. Must be a version of the form #.#.# .