-chlo-legalize-to-stablehlo
Légalisation du 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
Une carte expérimentale qui légalise les opérations liées aux formes aux opérations StableHLO.
Le fait de regrouper les calculs de forme et de données via une passe facultative permettent à l'écosystème StableHLO d'exploiter le potentiel Pipelines de compilation qui utilisent des opérations StableHLO pour modéliser le dynamisme.
-stablehlo-aggressive-folder
Permet de plier les opérations StableHLO
Options
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
Canonicalise les opérations StableHLO
-stablehlo-canonicalize-dynamism
Canonicalise les opérations StableHLO dynamiques en opérations statiques.
Remplace les opérations StableHLO dynamiques comme DynamicReshapeOp par les comme ReshapeOp si tous les éléments dynamiques de ces opérations sont en fait constantes.
Par exemple, si l'opérande "output_shape" de DynamicReshapeOp est une constante , l'opération peut être transformée en ReshapeOp.
-stablehlo-convert-to-signless
Réussite 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 ci-dessous:
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
Devenir:
func.call @bar(%arg0, %arg1)
Vous pouvez exclure un sous-ensemble de composites de cette transformation à l'aide de la méthode "sauf" indicateur, 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
Mentionnez les opérations obsolètes en opérations légitimes.
Le document RFC sur les abandons de l'opération StableHLO v1.0 (n° 2283) propose de supprimer plusieurs opérations redondantes. Cette réussite permet d'évaluer l'impact de ces opérations dans divers pipelines de compilation en les légalisant 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 (dé-quantifier, effectuer une opération à virgule flottante et quantifier) dans une opération quantifiée StableHLO
Fusionnez le modèle (dé-quantification, opération à virgule flottante et quantification) dans une opération quantifiée StableHLO. Remarque: La carte 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>>
}
Devenir:
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
Convertir des opérations quantifiées StableHLO en opérations mathématiques primitives StableHLO.
Convertir des programmes StableHLO à l'aide de types UniformQuantized en valeurs sémantiques des opérations mathématiques entières é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>>
}
Devenir:
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écomposer une opération StableHLO quantifiée en (dé-quantification, opération à virgule flottante et quantifier)
Décomposer des programmes quantifiés StableHLO à l'aide de quantification/déquantification uniformes opérations. 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>>
}
Devenir:
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 à 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 la valeur IR reste valide avant l'exécution du raffinement de forme.
Le refinedTypesOption peut être utilisé pour spécifier une liste de types affinés.
Vous pouvez le spécifier dans MLIR avec --types='tensor<...>,tensor<...>'.
transmis à la méthode de création de carte. La liste des types de filtre doit spécifier le
Type de chaque argument de la méthode main en cours d'affinement.
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.
Visite guidée d'un programme StableHLO affinant les formes au sein des opérations.
Le cas d'utilisation principal de cette carte est la spécialisation des programmes aux formes statiques. Si un programme StableHLO de forme dynamique possède le paramètre de la bonne structure, puis en remplaçant les types d'arguments dynamiques les formes statiques. L'exécution de cette carte entraîne la propagation des formes statiques le programme.
-vhlo-legalize-to-stablehlo
Légaliser le VHLO pour StableHLO.
-vhlo-to-version
Effectuez des conversions entre différentes versions de VHLO.
Options
-target : The target version. Must be a version of the form #.#.# or 'current'.