Bug 1949929 [wpt PR 50891] - webnn: implement quantizeLinear on coreml, a=testonly

Automatic update from web-platform-tests
webnn: implement quantizeLinear on coreml

Implement `quantizeLinear` using CoreML `quantize` op.

Add a cast_to_supported_type flag to `webnn_conformance_test` that skips
return early when input/output doesn't match opSupportLimits.
`buildAndExecuteGraphFunc` already has logic that handles implicit
casting.

Change-Id: I370ffccfa51b3156216c4504622bfb81543ea853
Bug: 385173305
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6289944
Reviewed-by: Reilly Grant <[email protected]>
Commit-Queue: Phillis Tang <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1423539}

--

wpt-commits: f33579b93fb82e61f0c5302f05caa94bc0a274d7
wpt-pr: 50891

Author: philloooo

testing/web-platform/tests/webnn/conformance_tests/dequantizeLinear.https.any.js

@@ -624,7 +624,8 @@ const dequantizeLinearTests = [
 if (navigator.ml) {
   dequantizeLinearTests.forEach((test) => {
     webnn_conformance_test(
-        buildAndExecuteGraph, getDequantizeLinearPrecisionTolerance, test);
+        buildAndExecuteGraph, getDequantizeLinearPrecisionTolerance, test,
+        /*cast_to_supported_type=*/ true);
   });
 } else {
   test(() => assert_implements(navigator.ml, 'missing navigator.ml'));

testing/web-platform/tests/webnn/conformance_tests/quantizeLinear.https.any.js

@@ -61,7 +61,51 @@ const quantizeLinearTests = [
     }
   },
   {
-    'name': 'quantizeLinear float32 1D constant tensor broadcasting zeroPoint',
+    'name': 'quantizeLinear float32 1D constant tensor',
+    'graph': {
+      'inputs': {
+        'quantizeLinearInput': {
+          'data': [
+            -2.549168109893799, -4.794857501983643, 8.413617134094238,
+            6.108623504638672
+          ],
+          'descriptor': {shape: [4], dataType: 'float32'},
+          'constant': true
+        },
+        'quantizeLinearScale': {
+          'data': [
+            9.343092918395996,
+            0.2800687253475189,
+            4.617084980010986,
+            1.1202747821807861,
+          ],
+          'descriptor': {shape: [4], dataType: 'float32'},
+          'constant': true
+        },
+        'quantizeLinearZeroPoint': {
+          'data': [128, 128, 128, 128],
+          'descriptor': {shape: [4], dataType: 'uint8'},
+          'constant': true
+        }
+      },
+      'operators': [{
+        'name': 'quantizeLinear',
+        'arguments': [
+          {'input': 'quantizeLinearInput'}, {'scale': 'quantizeLinearScale'},
+          {'zeroPoint': 'quantizeLinearZeroPoint'}
+        ],
+        'outputs': 'quantizeLinearOutput'
+      }],
+      'expectedOutputs': {
+        'quantizeLinearOutput': {
+          'data': [128, 111, 130, 133],
+          'descriptor': {shape: [4], dataType: 'uint8'}
+        }
+      }
+    }
+  },
+  {
+    'name': 'quantizeLinear float32 1D constant tensor with negative scale',
     'graph': {
       'inputs': {
         'quantizeLinearInput': {
@@ -185,8 +229,7 @@ const quantizeLinearTests = [
     }
   },
   {
-    'name':
-        'per-tensor quantizeLinear for float32 4D constant',
+    'name': 'per-tensor quantizeLinear for float32 4D constant',
     'graph': {
       'inputs': {
         'quantizeLinearInput': {
@@ -198,8 +241,10 @@ const quantizeLinearTests = [
           'constant': true
         },
         'quantizeLinearScale': {
-          'data': [0.2800687253475189, -4.617084980010986, 0.2800687253475189,
-                   -4.617084980010986],
+          'data': [
+            0.2800687253475189, -4.617084980010986, 0.2800687253475189,
+            -4.617084980010986
+          ],
           'descriptor': {shape: [2, 2], dataType: 'float32'},
           'constant': true
         },
@@ -535,7 +580,8 @@ const quantizeLinearTests = [
 if (navigator.ml) {
   quantizeLinearTests.forEach((test) => {
     webnn_conformance_test(
-        buildAndExecuteGraph, getQuantizeLinearPrecisionTolerance, test);
+        buildAndExecuteGraph, getQuantizeLinearPrecisionTolerance, test,
+        /*cast_to_supported_type=*/ true);
   });
 } else {
   test(() => assert_implements(navigator.ml, 'missing navigator.ml'));

testing/web-platform/tests/webnn/resources/utils.js

@@ -93,12 +93,17 @@ const kIntTypes =
     ['uint4', 'int4', 'uint8', 'int8', 'uint32', 'int32', 'uint64', 'int64'];
 const kFloatTypes = ['float16', 'float32'];
 
-const findCompatibleType = (dataType, supportedTypes) => {
+const findCompatibleType = (dataType, supportedTypes, castOpSupportLimits) => {
+  if (!castOpSupportLimits.input.dataTypes.includes(dataType)) {
+    // Cannot cast from `dataType` to any other type.
+    return null;
+  }
+
   for (let supportedType of supportedTypes) {
-    if (kIntTypes.includes(dataType)) {
-      if (kIntTypes.indexOf(supportedType) > kIntTypes.indexOf(dataType)) {
-        return supportedType;
-      }
+    if (kIntTypes.includes(dataType) &&
+        castOpSupportLimits.output.dataTypes.includes(dataType) &&
+        kIntTypes.indexOf(supportedType) > kIntTypes.indexOf(dataType)) {
+      return supportedType;
     }
 
     if (kFloatTypes.includes(dataType)) {
@@ -483,7 +488,8 @@ const createOperand = (context, builder, operandName, resources) => {
   // If input data type is not supported on current platform, attempt to use
   // a supported type to pass the data, then cast back to original type.
   if (!supportedDataTypes.includes(dataType)) {
-    const compatibleType = findCompatibleType(dataType, supportedDataTypes);
+    const compatibleType = findCompatibleType(
+        dataType, supportedDataTypes, context.opSupportLimits().cast);
     if (compatibleType) {
       descriptor.castedType = compatibleType;
       descriptor.dataType = compatibleType;
@@ -820,7 +826,8 @@ const buildAndExecuteGraph = async (context, builder, graphResources) => {
             expectedDescriptor.dataType)) {
       const compatibleType = findCompatibleType(
           expectedDescriptor.dataType,
-          context.opSupportLimits().output.dataTypes);
+          context.opSupportLimits().output.dataTypes,
+          context.opSupportLimits().cast);
       outputOperands[i] = builder.cast(outputOperands[i], compatibleType);
       expectedDescriptor.castedType = compatibleType;
     }
@@ -989,8 +996,12 @@ const getReducedElementCount =
           1;
     };
 
+// `cast_to_supported_type` will check if the graph input/output is
+// supported by current context, if not, it will try to find a compatible
+// type that's supported and use that type, then cast back to original type.
 const webnn_conformance_test =
-    (buildAndExecuteGraphFunc, toleranceFunc, testResources) => {
+    (buildAndExecuteGraphFunc, toleranceFunc, testResources,
+     cast_to_supported_type = false) => {
       promise_test(async () => {
         let context;
         try {
@@ -999,7 +1010,9 @@ const webnn_conformance_test =
           throw new AssertionError(
               `Unable to create context for ${variant} variant. ${e}`);
         }
-        validateContextSupportsGraph(context, testResources.graph);
+        if (!cast_to_supported_type) {
+          validateContextSupportsGraph(context, testResources.graph);
+        }
         const builder = new MLGraphBuilder(context);
         const {result, intermediateOperands} = await buildAndExecuteGraphFunc(
             context, builder, testResources.graph);