tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

round_even.https.any.js (6167B)

      1 // META: title=test WebNN API element-wise roundEven operation
      2 // META: global=window
      3 // META: variant=?cpu
      4 // META: variant=?gpu
      5 // META: variant=?npu
      6 // META: script=../resources/utils.js
      7 // META: timeout=long
      8 
      9 'use strict';
     10 
     11 // https://www.w3.org/TR/webnn/#api-mlgraphbuilder-unary
     12 // Round the input tensor with halves to the nearest even value, element-wise.
     13 //
     14 // MLOperand roundEven(MLOperand input);
     15 const getRoundEvenPrecisionTolerance = () => {
     16  return {metricType: 'ULP', value: 0};
     17 };
     18 
     19 const roundEvenTests = [
     20  // roundEven tests
     21  {
     22    'name': 'roundEven float32 positive 0D scalar',
     23    'graph': {
     24      'inputs': {
     25        'roundEvenInput': {
     26          'data': [1.5],
     27          'descriptor': {shape: [], dataType: 'float32'}
     28        }
     29      },
     30      'operators': [{
     31        'name': 'roundEven',
     32        'arguments': [{'input': 'roundEvenInput'}],
     33        'outputs': 'roundEvenOutput'
     34      }],
     35      'expectedOutputs': {
     36        'roundEvenOutput': {
     37          'data': [2],
     38          'descriptor': {shape: [], dataType: 'float32'}
     39        }
     40      }
     41    }
     42  },
     43  {
     44    'name': 'roundEven float32 negative 1D tensor',
     45    'graph': {
     46      'inputs': {
     47        'roundEvenInput': {
     48          'data': [-1.5],
     49          'descriptor': {shape: [1], dataType: 'float32'}
     50        }
     51      },
     52      'operators': [{
     53        'name': 'roundEven',
     54        'arguments': [{'input': 'roundEvenInput'}],
     55        'outputs': 'roundEvenOutput'
     56      }],
     57      'expectedOutputs': {
     58        'roundEvenOutput': {
     59          'data': [-2],
     60          'descriptor': {shape: [1], dataType: 'float32'}
     61        }
     62      }
     63    }
     64  },
     65  {
     66    'name': 'roundEven float32 2D tensor',
     67    'graph': {
     68      'inputs': {
     69        'roundEvenInput': {
     70          'data': [-1.5, 0.5],
     71          'descriptor': {shape: [1, 2], dataType: 'float32'}
     72        }
     73      },
     74      'operators': [{
     75        'name': 'roundEven',
     76        'arguments': [{'input': 'roundEvenInput'}],
     77        'outputs': 'roundEvenOutput'
     78      }],
     79      'expectedOutputs': {
     80        'roundEvenOutput': {
     81          'data': [-2, 0],
     82          'descriptor': {shape: [1, 2], dataType: 'float32'}
     83        }
     84      }
     85    }
     86  },
     87  {
     88    'name': 'roundEven float32 3D tensor',
     89    'graph': {
     90      'inputs': {
     91        'roundEvenInput': {
     92          'data': [-2.5, -1.5, 0.5, 1.5],
     93          'descriptor': {shape: [1, 2, 2], dataType: 'float32'}
     94        }
     95      },
     96      'operators': [{
     97        'name': 'roundEven',
     98        'arguments': [{'input': 'roundEvenInput'}],
     99        'outputs': 'roundEvenOutput'
    100      }],
    101      'expectedOutputs': {
    102        'roundEvenOutput': {
    103          'data': [-2, -2, 0, 2],
    104          'descriptor': {shape: [1, 2, 2], dataType: 'float32'}
    105        }
    106      }
    107    }
    108  },
    109  {
    110    'name': 'roundEven float32 4D tensor',
    111    'graph': {
    112      'inputs': {
    113        'roundEvenInput': {
    114          'data': [-2.5, -1.5, 0.5, 1.5],
    115          'descriptor': {shape: [1, 2, 1, 2], dataType: 'float32'}
    116        }
    117      },
    118      'operators': [{
    119        'name': 'roundEven',
    120        'arguments': [{'input': 'roundEvenInput'}],
    121        'outputs': 'roundEvenOutput'
    122      }],
    123      'expectedOutputs': {
    124        'roundEvenOutput': {
    125          'data': [-2, -2, 0, 2],
    126          'descriptor': {shape: [1, 2, 1, 2], dataType: 'float32'}
    127        }
    128      }
    129    }
    130  },
    131 
    132  // float16 tests
    133  {
    134    'name': 'roundEven float16 positive 0D scalar',
    135    'graph': {
    136      'inputs': {
    137        'roundEvenInput': {
    138          'data': [1.5],
    139          'descriptor': {shape: [], dataType: 'float16'}
    140        }
    141      },
    142      'operators': [{
    143        'name': 'roundEven',
    144        'arguments': [{'input': 'roundEvenInput'}],
    145        'outputs': 'roundEvenOutput'
    146      }],
    147      'expectedOutputs': {
    148        'roundEvenOutput': {
    149          'data': [2],
    150          'descriptor': {shape: [], dataType: 'float16'}
    151        }
    152      }
    153    }
    154  },
    155  {
    156    'name': 'roundEven float16 negative 1D tensor',
    157    'graph': {
    158      'inputs': {
    159        'roundEvenInput': {
    160          'data': [-1.5],
    161          'descriptor': {shape: [1], dataType: 'float16'}
    162        }
    163      },
    164      'operators': [{
    165        'name': 'roundEven',
    166        'arguments': [{'input': 'roundEvenInput'}],
    167        'outputs': 'roundEvenOutput'
    168      }],
    169      'expectedOutputs': {
    170        'roundEvenOutput': {
    171          'data': [-2],
    172          'descriptor': {shape: [1], dataType: 'float16'}
    173        }
    174      }
    175    }
    176  },
    177  {
    178    'name': 'roundEven float16 2D tensor',
    179    'graph': {
    180      'inputs': {
    181        'roundEvenInput': {
    182          'data': [-1.5, 0.5],
    183          'descriptor': {shape: [1, 2], dataType: 'float16'}
    184        }
    185      },
    186      'operators': [{
    187        'name': 'roundEven',
    188        'arguments': [{'input': 'roundEvenInput'}],
    189        'outputs': 'roundEvenOutput'
    190      }],
    191      'expectedOutputs': {
    192        'roundEvenOutput': {
    193          'data': [-2, 0],
    194          'descriptor': {shape: [1, 2], dataType: 'float16'}
    195        }
    196      }
    197    }
    198  },
    199  {
    200    'name': 'roundEven float16 3D tensor',
    201    'graph': {
    202      'inputs': {
    203        'roundEvenInput': {
    204          'data': [-2.5, -1.5, 0.5, 1.5],
    205          'descriptor': {shape: [1, 2, 2], dataType: 'float16'}
    206        }
    207      },
    208      'operators': [{
    209        'name': 'roundEven',
    210        'arguments': [{'input': 'roundEvenInput'}],
    211        'outputs': 'roundEvenOutput'
    212      }],
    213      'expectedOutputs': {
    214        'roundEvenOutput': {
    215          'data': [-2, -2, 0, 2],
    216          'descriptor': {shape: [1, 2, 2], dataType: 'float16'}
    217        }
    218      }
    219    }
    220  },
    221  {
    222    'name': 'roundEven float16 4D tensor',
    223    'graph': {
    224      'inputs': {
    225        'roundEvenInput': {
    226          'data': [-2.5, -1.5, 0.5, 1.5],
    227          'descriptor': {shape: [1, 2, 1, 2], dataType: 'float16'}
    228        }
    229      },
    230      'operators': [{
    231        'name': 'roundEven',
    232        'arguments': [{'input': 'roundEvenInput'}],
    233        'outputs': 'roundEvenOutput'
    234      }],
    235      'expectedOutputs': {
    236        'roundEvenOutput': {
    237          'data': [-2, -2, 0, 2],
    238          'descriptor': {shape: [1, 2, 1, 2], dataType: 'float16'}
    239        }
    240      }
    241    }
    242  },
    243 ]
    244 
    245 webnn_conformance_test(
    246    roundEvenTests, buildAndExecuteGraph, getRoundEvenPrecisionTolerance);