.. _l-onnx-opai-onnx-ml-labelencoder-d1-2:

LabelEncoder - 1 vs 2
=====================

Next section compares an older to a newer version of the same operator 
after both definition are converted into markdown text.
Green means an addition to the newer version, red means a deletion.
Anything else is unchanged.

.. raw:: html


    <div id="div_LabelEncoder_3"></div>
    <link rel="stylesheet" type="text/css" href="../_static/diff2html.min.css" />
    <script type="text/javascript" src="../_static/diff2html-ui-slim.min.js"></script>
    <script>
    const diffString = `
    --- a/LabelEncoder1
    +++ b/LabelEncoder2
    @@ -1 +1 @@
    - Converts strings to integers and vice versa.<br>
    - If the string default value is set, it will convert integers to strings.
    - If the int default value is set, it will convert strings to integers.<br>
    - Each operator converts either integers to strings or strings to integers, depending
    - on which default value attribute is provided. Only one default value attribute
    - should be defined.<br>
    - When converting from integers to strings, the string is fetched from the
    - 'classes_strings' list, by simple indexing.<br>
    - When converting from strings to integers, the string is looked up in the list
    - and the index at which it is found is used as the converted value.
    + Maps each element in the input tensor to another value.<br>
    + The mapping is determined by the two parallel attributes, 'keys_*' and
    + 'values_*' attribute. The i-th value in the specified 'keys_*' attribute
    + would be mapped to the i-th value in the specified 'values_*' attribute. It
    + implies that input's element type and the element type of the specified
    + 'keys_*' should be identical while the output type is identical to the
    + specified 'values_*' attribute. If an input element can not be found in the
    + specified 'keys_*' attribute, the 'default_*' that matches the specified
    + 'values_*' attribute may be used as its output value.<br>
    + Let's consider an example which maps a string tensor to an integer tensor.
    + Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
    + and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
    + "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
    + Since this operator is an one-to-one mapping, its input and output shapes
    + are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
    + For key look-up, bit-wise comparison is used so even a float NaN can be
    + mapped to a value in 'values_*' attribute.<br>
  
      ### Attributes
  
    - * **classes_strings - STRINGS** :
    + * **default_float - FLOAT** (default is '-0.0'):
  
    -   A list of labels.
    +   A float.
  
      * **default_int64 - INT** (default is '-1'):
  
    -   An integer to use when an input string value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.
    +   An integer.
  
      * **default_string - STRING** (default is '_Unused'):
  
    -   A string to use when an input integer value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.
    +   A string.
    + 
    + * **keys_floats - FLOATS** :
    + 
    +   A list of floats.
    + 
    + * **keys_int64s - INTS** :
    + 
    +   A list of ints.
    + 
    + * **keys_strings - STRINGS** :
    + 
    +   A list of strings. One and only one of 'keys_*'s should be set.
    + 
    + * **values_floats - FLOATS** :
    + 
    +   A list of floats.
    + 
    + * **values_int64s - INTS** :
    + 
    +   A list of ints.
    + 
    + * **values_strings - STRINGS** :
    + 
    +   A list of strings. One and only one of 'value_*'s should be set.
  
      ### Inputs
  
      - **X** (heterogeneous) - **T1**:
  
    -   Input data.
    +   Input data. It can be either tensor or scalar.
  
      ### Outputs
  
      - **Y** (heterogeneous) - **T2**:
  
    -   Output data. If strings are input, the output values are integers, and vice versa.
    +   Output data.
  
      ### Type Constraints
  
    - * **T1** in ( tensor(int64), tensor(string) ):
    + * **T1** in ( tensor(float), tensor(int64), tensor(string) ):
    ?              +++++++++++++++
  
    -   The input type must be a tensor of integers or strings, of any shape.
    +   The input type is a tensor of any shape.
    - * **T2** in ( tensor(int64), tensor(string) ):
    + * **T2** in ( tensor(float), tensor(int64), tensor(string) ):
    ?              +++++++++++++++
  
    -   The output type will be a tensor of strings or integers, and will have the same shape as the input.+   Output type is determined by the specified 'values_*' attribute.
    `;

    document.addEventListener('DOMContentLoaded', function () {
    var targetElement = document.getElementById('div_LabelEncoder_3');
    var configuration = {
        drawFileList: true,
        fileListToggle: false,
        fileListStartVisible: false,
        fileContentToggle: false,
        matching: 'lines',
        outputFormat: 'line-by-line',
        synchronisedScroll: true,
        highlight: true,
        renderNothingWhenEmpty: false,
    };
    var diff2htmlUi = new Diff2HtmlUI(targetElement, diffString, configuration);
    diff2htmlUi.draw();
    diff2htmlUi.highlightCode();
    });
    </script>