OpenXLA Project

Se usó la API de Cloud Translation para traducir esta página.

`-chlo-legalize-to-stablehlo`

Legaliza el flujo de operaciones de CHLO a StableHLO y operaciones de Shape

`-shape-legalize-to-stablehlo`

Se legalizaron las operaciones relacionadas con la forma en StableHLO.

Un pase experimental que legaliza las operaciones relacionadas con la forma a las operaciones de StableHLO.

Combinar las computaciones de forma y datos a través de un pase opcional permitirá que el ecosistema de StableHLO aproveche potencialmente las canalizaciones de compilación que usan operaciones de StableHLO para modelar el dinamismo.

`-stablehlo-aggressive-folder`

Une las operaciones de StableHLO

Opciones

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

`-stablehlo-aggressive-simplification`

Canoniza las operaciones de StableHLO

`-stablehlo-canonicalize-dynamism`

Canoniza las operaciones de StableHLO dinámicas en operaciones estáticas.

Reemplaza las operaciones de StableHLO dinámicas, como DynamicReshapeOp, por las contrapartes estáticas correspondientes, como DynamicReshapeOp a ReshapeOp o DynamicBroadcastInDim a BroadcastInDim, si todos los elementos dinámicos de estas operaciones son, en realidad, 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`

Expansor de compatibilidad para operaciones de StableHLO.

Las operaciones de StableHLO reciben actualizaciones o se introducen operaciones nuevas en las versiones más recientes. Este pase de habilitación expande la retrocompatibilidad con versiones anteriores de StableHLO, ya que descompone las operaciones de StableHLO más recientes en operaciones equivalentes compatibles con esas versiones anteriores.

¿Por qué es un pase con solicitud de aceptación?

En ocasiones, se usan mejoras de operaciones de StableHLO para simplificar en gran medida el manejo de ciertos patrones comunes en el ecosistema de OpenXLA. Esto incluye elementos como TanOp, que tiene una alta compatibilidad con el framework y el compilador, así como dimensiones de lotes de recopilación o dispersión, que se pueden representar con rebanadas, pero que dificultan mucho la fragmentación. Para esta categoría de funciones nuevas, no ofrecemos la baja automática, ya que podría descartar información importante que se usa en optimizaciones posteriores. Este pase se puede usar para expandir estas operaciones en función de una versión objetivo para maximizar la compatibilidad a costa de una compilación potencialmente menos óptima.

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

Opciones

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

`-stablehlo-convert-to-signless`

Pasa para transformar el IR en números enteros sin signo.

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

Reemplaza las operaciones compuestas por una llamada a su descomposición.

Reemplaza las operaciones compuestas por una llamada a su descomposición, p.ej., la siguiente:

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

Se convertirá en lo siguiente:

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

Se puede exceptuar un subconjunto de compuestos de esta transformación con la marca “excepto”, p.ej.:

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

Opciones

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

`-stablehlo-legalize-deprecated-ops`

Legaliza las operaciones obsoletas para que sean compatibles.

En la RFC de baja de conjuntos de operaciones de StableHLO v1.0 (#2283), se propone quitar varias operaciones redundantes. Este pase ayuda a evaluar el impacto de estas eliminaciones de operaciones en varias canalización de compilación, ya que las legaliza a sus contrapartes compatibles a largo plazo.

Opciones

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

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

Combina (descuantifica, opera con números de punto flotante y cuantifica) el patrón en la operación cuantificada de StableHLO

Combina (descuantifica, opera con números de punto flotante y cuantifica) el patrón en la operación cuantificada de StableHLO. Nota: El pase no borra ninguna operación preexistente. Por ejemplo, el siguiente programa

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

Se convertirá en lo siguiente:

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`

Convierte las operaciones quantizadas de StableHLO en operaciones matemáticas primitivas de StableHLO.

Convierte programas de StableHLO con tipos UniformQuantized en operaciones matemáticas de números enteros equivalentes semánticamente.

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

Se convertirá en lo siguiente:

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`

Descompone la operación quantized StableHLO en el patrón (descuantizar, operación de punto flotante y cuantificar).

Descompone los programas cuantificados de StableHLO con operaciones de cuantificación y descuantización uniformes. Por ejemplo, el siguiente programa

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

Se convertirá en lo siguiente:

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`

Se legalizó StableHLO para VHLO.

`-stablehlo-refine-arguments`

Define mejor las formas de los argumentos de la función principal.

Modifica los argumentos de la función principal con la firma del tipo de entrada. Une los argumentos en custom_call @stablehlo.shape_refinement_operand_wrapper para mantener el IR válido antes de que se ejecute el perfeccionamiento de la 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>
  ...

Se puede usar refinedTypesOption para especificar una lista de tipos refinados. Esto se puede especificar en MLIR con --types='tensor<...>,tensor<...>' o pasarse al método de creación de pases. La lista de tipos de perfeccionamiento debe especificar el tipo de cada argumento del método main que se está definiendo mejor.

Opciones

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

`-stablehlo-refine-shapes`

Perfeccionar las formas en un programa de StableHLO

Explica un programa de StableHLO que define mejor las formas dentro de las operaciones.

El caso de uso principal de este pase es especializar programas con formas dinámicas en formas estáticas. Si un programa de StableHLO con forma dinámica tiene la estructura correcta, actualizar sus tipos de argumentos de formas dinámicas a formas estáticas y ejecutar este pase propagará las formas estáticas en todo el programa.

Este pase quita custom_call @shape_refinement_operand_wrapper reemplazando los usos del resultado por el operando directamente y propaga las formas estáticas en todo el programa.

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

Los módulos válidos para el perfeccionamiento de la forma deben tener las siguientes propiedades:

Todas las formas dinámicas dependen solo de las formas de entrada (no hay dependencia de forma en el contenido del array de entrada). Nos referimos a las operaciones que dependen de forma transitiva solo de las formas de entrada (p. ej., como se indica en stablehlo.get_dimension_size) o constantes globales, como los valores resueltos de números enteros simbólicos (es decir, tensor : A = 5), como operaciones dimension. Todos los valores de dimensión se pueden resolver en constantes a través de la reducción de constantes interprocedural.
Las funciones intermedias pueden tomar una serie de argumentos de token (de tipo !stablehlo.token) al comienzo de la lista de argumentos, seguidos de algunos argumentos constantes globales que son escalares enteros constantes, como los valores resueltos de números enteros simbólicos (es decir, tensor : A = 5).
Algunas funciones intermedias pueden mostrar cálculos en constantes globales, es decir, floordiv en valores de symint. Estas funciones se indican solo cuando se muestran valores constantes después de la mejora. Estas funciones se intercalan.
Todas las llamadas a una sola función se resuelven en las mismas formas de argumentos y no se realizan llamadas a funciones recursivas ni co-recursivas. ### -vhlo-legalize-to-stablehlo

Se legalizó VHLO a StableHLO.

`-vhlo-to-version`

Convierte entre versiones de VHLO.

Opciones

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