Fix dropout lowering, reject unwritten reads, speed up input quantization

- Quantizer: aten.dropout/dropout_ and alias share their input's qparams.
  Without this, a Linear after an eval-mode Dropout (MobileNetV2/V3
  classifiers) observed its own input and the delegate read a tensor that
  no operation wrote.
- Serializer: collapse the q -> dq -> q -> dq chain that a decomposed
  identity op leaves behind, and reject it if the qparams differ.
- serialize_graph checks that every operation reads only graph inputs,
  constants or tensors written earlier.
- Delegate: quantize float inputs with a two-op round-half-to-even instead
  of nearbyintf, which is a software routine on Xtensa, and write the NHWC
  destination sequentially. On MobileNetV3-Small 224 the input conversion
  drops from about 93 ms to 33 ms. All e2e programs give the same results.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: CodeKitty-max

backends/espressif/espnn_runtime/src/espnn_backend.cpp

@@ -50,6 +50,12 @@ namespace {
 
 DelegateStats g_stats{};
 
+constexpr float kHalfEvenRoundingBias = 12582912.0f;
+
+float round_half_even_below_2p22(float value) {
+  return (value + kHalfEvenRoundingBias) - kHalfEvenRoundingBias;
+}
+
 int8_t quantize(float value, float inverse_scale, int32_t zero_point) {
   const float scaled = value * inverse_scale;
   if (!std::isfinite(scaled))
@@ -58,7 +64,8 @@ int8_t quantize(float value, float inverse_scale, int32_t zero_point) {
     return 127;
   if (scaled < -1.0e6f)
     return -128;
-  int32_t q = static_cast<int32_t>(std::nearbyintf(scaled)) + zero_point;
+  int32_t q =
+      static_cast<int32_t>(round_half_even_below_2p22(scaled)) + zero_point;
   if (q < -128)
     q = -128;
   if (q > 127)
@@ -98,8 +105,8 @@ bool load_input(
         destination[i] = quantize(source[i], inverse, info.zero_point);
       return true;
     }
-    for (size_t c = 0; c < channels; ++c) {
-      for (size_t p = 0; p < plane; ++p) {
+    for (size_t p = 0; p < plane; ++p) {
+      for (size_t c = 0; c < channels; ++c) {
         destination[p * channels + c] =
             quantize(source[c * plane + p], inverse, info.zero_point);
       }

backends/espressif/quantizer/espnn_quantizer.py

@@ -301,6 +301,9 @@ def annotate_unary_and_softmax(
     torch.ops.aten.upsample_bilinear2d.default,
     torch.ops.aten.constant_pad_nd.default,
     torch.ops.aten.pad.default,
+    torch.ops.aten.dropout.default,
+    torch.ops.aten.dropout_.default,
+    torch.ops.aten.alias.default,
 )
 
 SPLIT_TARGETS = (

backends/espressif/serialization/xts3.py

@@ -611,8 +611,23 @@ def _get_or_create_int8(  # noqa: C901
                         quantized_node, float(node.args[1]), int(node.args[2])
                     )
                 return self._constant_int8(node)
+            source = quantized_node.args[0]
+            if getattr(
+                source, "op", None
+            ) == "call_function" and "dequantize_per_tensor" in str(source.target):
+                # q(dq(x)) is left behind where an identity op (such as an
+                # eval-mode dropout) was decomposed away.
+                if (float(source.args[1]), int(source.args[2])) != (
+                    float(node.args[1]),
+                    int(node.args[2]),
+                ):
+                    raise ValueError(
+                        f"{quantized_node.name} requantizes {source.name}; "
+                        "back-to-back requantization is not supported"
+                    )
+                return self._get_or_create_int8(source, filter_layout)
             return self._new_int8_activation(
-                quantized_node.args[0],
+                source,
                 float(node.args[1]),
                 int(node.args[2]),
             )
@@ -1917,9 +1932,35 @@ def check_runtime_limits(graph: XTS3Graph) -> None:
             raise ValueError(f"int32 constant {tensor.tensor_id} is not 4-byte aligned")
 
 
+def check_dataflow(graph: XTS3Graph) -> None:
+    """
+    Raise ValueError when an operation or graph output reads an activation
+    that is neither a graph input nor written by an earlier operation. The
+    device would read whatever its arena holds there.
+    """
+    ready = set(graph.inputs)
+    ready.update(
+        tensor.tensor_id
+        for tensor in graph.tensors
+        if tensor.flags & TENSOR_FLAG_CONSTANT
+    )
+    for index, operation in enumerate(graph.operations):
+        for tensor_id in operation.inputs:
+            if tensor_id >= 0 and tensor_id not in ready:
+                raise ValueError(
+                    f"Operation {index} ({XTS3OpCode(operation.opcode).name}) "
+                    f"reads tensor {tensor_id}, which nothing writes before it"
+                )
+        ready.update(operation.outputs)
+    for tensor_id in graph.outputs:
+        if tensor_id not in ready:
+            raise ValueError(f"Graph output {tensor_id} is never written")
+
+
 def serialize_graph(graph: XTS3Graph) -> bytes:
     """Serialize to the XTS3 wire format; constants start 16-byte aligned."""
     check_runtime_limits(graph)
+    check_dataflow(graph)
     tensor_data = b"".join(_serialize_tensor(tensor) for tensor in graph.tensors)
     parameter_data = bytearray()
     operation_data = bytearray()

backends/espressif/test/test_contracts.py

@@ -34,8 +34,10 @@
     EspNNQuantizer,
     fused_activation_kind,
 )
+from executorch.backends.espressif.reference import ProgramEmulator  # noqa: E402
 from executorch.backends.espressif.serialization.xts3 import (  # noqa: E402
     build_graph,
+    check_dataflow,
     check_runtime_limits,
     MAX_GRAPH_IO,
     MAX_GRAPH_OPERATIONS,
@@ -171,3 +173,54 @@ def test_runtime_limits_reject_misaligned_int32_constants():
     ]
     with pytest.raises(ValueError, match="4-byte aligned"):
         check_runtime_limits(dataclasses.replace(graph, tensors=tensors))
+
+
+class DropoutClassifier(nn.Module):
+    """MobileNetV3's classifier: Linear, Hardswish, in-place Dropout, Linear."""
+
+    def __init__(self):
+        super().__init__()
+        self.head = nn.Sequential(
+            nn.Linear(16, 32),
+            nn.Hardswish(inplace=True),
+            nn.Dropout(0.2, inplace=True),
+            nn.Linear(32, 10),
+        )
+
+    def forward(self, x):
+        return self.head(x)
+
+
+def test_dropout_between_quantized_ops_reads_the_producer():
+    converted, program = quantize(DropoutClassifier(), [(1, 16)])
+    graph = build_graph(program)
+    check_dataflow(graph)
+    last = graph.operations[-1]
+    assert last.opcode == XTS3OpCode.LINEAR
+    assert last.inputs[0] in graph.operations[-2].outputs
+
+    edge, report = to_espnn_edge(program, allow_cpu_fallback=False)
+    assert report["partitions"] == 1
+    x = torch.randn(1, 16)
+    expected = converted(x)
+    actual = ProgramEmulator(edge.exported_program())(x).to(torch.float32)
+    assert torch.allclose(actual, expected, atol=0.2)
+
+
+def test_dataflow_rejects_reading_an_unwritten_activation():
+    graph = _small_graph()
+    unwritten = dataclasses.replace(
+        graph.tensors[graph.operations[-1].inputs[0]],
+        tensor_id=len(graph.tensors),
+    )
+    last = dataclasses.replace(
+        graph.operations[-1],
+        inputs=[unwritten.tensor_id, *graph.operations[-1].inputs[1:]],
+    )
+    broken = dataclasses.replace(
+        graph,
+        tensors=[*graph.tensors, unwritten],
+        operations=[*graph.operations[:-1], last],
+    )
+    with pytest.raises(ValueError, match="nothing writes"):
+        check_dataflow(broken)