-chlo-legalize-to-stablehlo
Legalização do fluxo de operações CHLO para StableHLO e Shape ops
-shape-legalize-to-stablehlo
Legalize operações relacionadas a formas para o StableHLO.
Uma passagem experimental que legaliza operações relacionadas a formas para operações StableHLO.
Unir cálculos de forma e de dados com uma passagem opcional vai possibilitam que o ecossistema StableHLO aproveite o potencial pipelines de compilação que usam operações do StableHLO para modelar o dinamismo.
-stablehlo-aggressive-folder
Dobre as operações StableHLO
Opções
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
Canoniza as operações StableHLO
-stablehlo-canonicalize-dynamism
Canoniza operações StableHLO dinâmicas em operações estáticas.
Substitui as operações dinâmicas do StableHLO, como DynamicReshapeOp, pelo código equivalentes estáticos, como ReshapeOp, se todos os elementos dinâmicos dessas operações são constantes.
Por exemplo, se o operando output_shape de DynamicReshapeOp for uma constante valor, a operação poderá ser transformada em ReshapeOp.
-stablehlo-convert-to-signless
Passe para transformar o IR em números inteiros sem sinal.
-stablehlo-legalize-composite-to-call
Substitui operações compostas por uma chamada para a decomposição delas
Substitui operações compostas por uma chamada para sua decomposição, por exemplo, o seguinte:
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
Vai ser:
func.call @bar(%arg0, %arg1)
Um subconjunto de compostos pode ser excluído dessa transformação usando o "exceto" por exemplo:
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
Opções
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
Legalize as operações descontinuadas para outras com suporte.
O RFC (#2283) das descontinuações de operações do StableHLO v1.0 propõe remover várias operações redundantes. Isso ajuda a avaliar o impacto remoções em vários pipelines de compilação legalizando-os para com suporte de longo prazo.
Opções
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
Fusir o padrão (desquantização, operação de ponto flutuante e quantização) na operação quantizada do StableHLO
Fundir (desquantizar, operação de ponto flutuante e quantizar) na operação quantizada StableHLO Observação: o cartão não exclui nenhuma operação atual. Por exemplo, o programa a seguir
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>>
}
Vai ser:
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
Converta de operações quantizadas de StableHLO em operações matemáticas primitivas de StableHLO.
Converter programas StableHLO usando tipos Uniformquantized para operações matemáticas de números inteiros equivalentes.
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>>
}
Vai ser:
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
Decompor a operação StableHLO quantizada para padrões de desquantização, operação de ponto flutuante e quantização.
Decompor programas quantizados StableHLO usando quantização/desquantização uniforme as operações. Por exemplo, o programa a seguir
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>>
}
Vai ser:
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
Legalize o StableHLO para VHLO.
-stablehlo-refine-arguments
Refina as formas do argumento da função principal.
Modifica os argumentos da função principal usando a assinatura do tipo de entrada. Encapsula argumentos em custom_call @stablehlo.shape_refinement_operando_wrapper para manter a IR válida antes que o refinamento da forma seja executado.
O refinedTypesOption pode ser usado para especificar uma lista de tipos refinados.
Isso pode ser especificado no MLIR com --types='tensor<...>,tensor<...>' ou
passados para o método de criação de cartão. A lista de tipos de refinamento deve especificar o
tipo de cada argumento para o método main que está sendo refinado.
Opções
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
Refina formas em um programa StableHLO.
Mostra um programa StableHLO refinando formas dentro das operações.
O principal caso de uso desse passe é especializado em modelos dinâmicos programas a formas estáticas. Se um programa StableHLO de forma dinâmica tiver a estrutura direita e, em seguida, atualizando seus tipos de argumento de formas dinâmicas para formas estáticas, e executar esta passagem propagará formas estáticas no programa.
-vhlo-legalize-to-stablehlo
Legalize o VHLO para o StableHLO.
-vhlo-to-version
Converta entre versões do VHLO.
Opções
-target : The target version. Must be a version of the form #.#.# or 'current'.