OpenXLA Project

Cette page a été traduite par l'API Cloud Translation.

`-chlo-legalize-to-stablehlo`

Légalise le flux d'opérations CHLO vers les opérations StableHLO et Shape

`-shape-legalize-to-stablehlo`

Légalisation des opérations liées aux formes dans StableHLO.

Passage expérimental qui légalise les opérations liées à la forme en opérations StableHLO.

En combinant les calculs de forme et de données via un passage facultatif, l'écosystème StableHLO pourra potentiellement exploiter les pipelines de compilation qui utilisent des opérations StableHLO pour modéliser le dynamisme.

`-stablehlo-aggressive-folder`

Plie les opérations StableHLO

Options

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

`-stablehlo-aggressive-simplification`

Canonise les opérations StableHLO

`-stablehlo-canonicalize-dynamism`

Canonique les opérations StableHLO dynamiques en opérations statiques.

Remplace les opérations StableHLO dynamiques telles que DynamicReshapeOp par les homologues statiques correspondantes, par exemple DynamicReshapeOp par ReshapeOp ou DynamicBroadcastInDim par BroadcastInDim si tous les éléments dynamiques de ces opérations sont en réalité des constantes.

  %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`

Développeur de compatibilité pour les opérations StableHLO

Les opérations StableHLO sont mises à jour ou une nouvelle opération est introduite dans les dernières versions. Cette option activable étend la rétrocompatibilité avec les anciennes versions de StableHLO en décomposant les nouvelles opérations StableHLO en opérations équivalentes compatibles avec ces anciennes versions.

Pourquoi cette carte est-elle facultative ?

Parfois, des améliorations des opérations StableHLO sont utilisées pour simplifier considérablement la gestion de certains modèles courants dans l'écosystème OpenXLA. Cela inclut des éléments tels que TanOp, qui offre une compatibilité élevée avec le framework et le compilateur, ainsi que des dimensions de traitement par lot de collecte/diffusion, qui peuvent être représentées à l'aide de tranches, mais qui rendent le fractionnement beaucoup plus difficile. Pour cette catégorie de nouvelles fonctionnalités, nous n'offrons pas de rétrogradation automatique, car elle pourrait supprimer des informations importantes utilisées lors des optimisations ultérieures. Cette étape peut être utilisée pour développer ces opérations en fonction d'une version cible afin de maximiser la compatibilité au détriment d'une compilation potentiellement moins optimale.

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

Options

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

`-stablehlo-convert-to-signless`

Pass pour transformer l'IR en entiers sans signe.

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

Remplace les opérations composites par un appel à leur décomposition.

Remplace les opérations composites par un appel à leur décomposition, par exemple:

stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
  decomposition = @bar,
  version = 1,
  composite_attributes = {
    "my_attribute": "my_value"
  }
}

Deviendra:

func.call @bar(%arg0, %arg1)

Vous pouvez exclure un sous-ensemble de composites de cette transformation à l'aide de l'indicateur "except", par exemple :

stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'

Options

-except : Names of composites that should not be replaced with calls.

`-stablehlo-legalize-deprecated-ops`

Légalisez les opérations obsolètes en les remplaçant par des opérations bien prises en charge.

La RFC 2283 sur l'abandon des opérations StableHLO v1.0 propose de supprimer plusieurs opérations redondantes. Cette étape permet d'évaluer l'impact de ces suppressions d'opérations dans divers pipelines de compilation en les légalisant par rapport à leurs homologues compatibles à long terme.

Options

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

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

Fusionner le modèle (déquantisation, opération à virgule flottante et quantification) dans l'opération quantifiée StableHLO

Fusionner le modèle (déquantisation, opération à virgule flottante et quantification) dans l'opération quantifiée StableHLO Remarque: L'étape ne supprime aucune opération préexistante. Par exemple, le programme suivant

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

Deviendra:

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`

Convertissez les opérations quantiques StableHLO en opérations mathématiques primitives StableHLO.

Convertissez les programmes StableHLO utilisant des types UniformQuantized en opérations mathématiques entières sémantiquement équivalentes.

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

Deviendra:

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`

Décomposez l'opération StableHLO linéarisée en modèle (délinéarisation, opération à virgule flottante et linéarisation).

Décomposez les programmes quantifiés StableHLO à l'aide d'opérations de quantification/déquantification uniformes. Par exemple, le programme suivant :

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

Deviendra:

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`

Légaliser StableHLO en tant que VHLO.

`-stablehlo-refine-arguments`

Affine les formes d'argument de la fonction principale.

Modifie les arguments de la fonction principale à l'aide de la signature du type d'entrée. Encapsule les arguments dans custom_call @stablehlo.shape_refinement_operand_wrapper pour que l'IR reste valide avant l'exécution de l'affinage de la forme.

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 permet de spécifier une liste de types affinés. Cela peut être spécifié dans MLIR avec --types='tensor<...>,tensor<...>' ou transmis à la méthode de création de la carte. La liste de types de raffinement doit spécifier le type de chaque argument de la méthode main à affiner.

Options

-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'

`-stablehlo-refine-shapes`

Affine les formes dans un programme StableHLO.

Présente un programme StableHLO qui affine les formes dans les opérations.

Le cas d'utilisation principal de cette carte consiste à spécialiser des programmes de forme dynamique en formes statiques. Si un programme StableHLO de forme dynamique présente la structure appropriée, la mise à jour de ses types d'arguments de formes dynamiques en formes statiques et l'exécution de cette étape propageront les formes statiques dans le programme.

Cette étape supprime custom_call @shape_refinement_operand_wrapper en remplaçant directement les utilisations du résultat par l'opérande, et propage les formes statiques dans tout le programme.

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

Les modules valides pour l'affinage de la forme doivent présenter les propriétés suivantes:

Toutes les formes dynamiques ne dépendent que des formes d'entrée (aucune dépendance de forme sur le contenu du tableau d'entrée). Nous appelons "opérations dimension" les opérations qui ne dépendent que transitivement des formes d'entrée (par exemple, comme indiqué par stablehlo.get_dimension_size) ou des constantes globales telles que les valeurs résolues des entiers symboliques (c'est-à-dire le tenseur : A = 5). Toutes les valeurs de dimension peuvent être résolues en constantes via le pliage de constantes interprocédural.
Les fonctions intermédiaires peuvent prendre un certain nombre d'arguments de jeton (de type !stablehlo.token) au début de la liste d'arguments, suivis de quelques arguments de constante globale qui sont des scalaires entiers constants, tels que les valeurs résolues des entiers symboliques (c'est-à-dire le tenseur : A = 5).
Certaines fonctions intermédiaires peuvent renvoyer des calculs sur des constantes globales, c'est-à-dire floordiv sur des valeurs symint. Ces fonctions ne renvoient que des valeurs constantes après affinement. Ces fonctions sont intégrées.
Tous les appels à une seule fonction se résolvent aux mêmes formes d'arguments, et aucun appel de fonction récursif / co-récursif n'est effectué. ### -vhlo-legalize-to-stablehlo

Légaliser VHLO en tant que StableHLO.

`-vhlo-to-version`

Convertir des versions de VHLO

Options

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