Add `ResizeBilinear` operator by federico-pizz · Pull Request #9 · matteocarnelos/microflow-rs

federico-pizz · 2025-12-28T18:55:42Z

Added support for the resize bilinear tflite operator. Also remove the warning thrown.

Copilot

Pull request overview

This PR adds support for the ResizeBilinear TFLite operator, enabling bilinear image resizing with support for quantized tensors (i8 and u8). The implementation includes proper handling of alignment options (align_corners and half_pixel_centers) and requantization logic.

Implements bilinear interpolation algorithm with coordinate mapping and boundary clamping
Adds operator parsing and code generation in the macro system
Includes comprehensive test coverage for upscaling, downscaling, and different alignment modes

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
src/ops/resize_bilinear.rs	Core implementation of the resize_bilinear operator with bilinear interpolation algorithm and comprehensive tests
src/ops/mod.rs	Exports the new resize_bilinear module
microflow-macros/src/ops/resize_bilinear.rs	Macro implementation for parsing TFLite ResizeBilinear operators and generating Rust code
microflow-macros/src/ops/mod.rs	Declares the resize_bilinear module in the macro crate
microflow-macros/src/lib.rs	Integrates ResizeBilinear operator handling into the model macro
microflow-macros/flatbuffers/tflite_generated.rs	Adds explicit lifetime annotations to Model return types in flatbuffers-generated code

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2025-12-28T18:59:02Z

+            // Validate for NaN/infinity and use safe conversion
+            let clamped = if requantized.is_nan() || requantized.is_infinite() {
+                0.0f32 // Default to zero for invalid results
+            } else {
+                requantized
+            };
+
+            // Use safe conversion with fallback to zero
+            out_channels[i] = T::from_superset(&clamped).unwrap_or_else(|| T::from_superset_unchecked(&0.0f32));


The error handling here appears more defensive than other operators in the codebase. Lines 86-90 handle NaN/infinity by setting to 0.0f32, and then line 93 uses from_superset with unwrap_or_else for safe conversion. Other operators (conv_2d, average_pool_2d, depthwise_conv_2d) simply use from_superset_unchecked after roundf. Consider simplifying this to match the pattern used elsewhere in the codebase for consistency, unless there's a specific reason resize_bilinear needs extra safety checks.

Suggested change

// Validate for NaN/infinity and use safe conversion

let clamped = if requantized.is_nan() || requantized.is_infinite() {

0.0f32 // Default to zero for invalid results

} else {

requantized

};

// Use safe conversion with fallback to zero

out_channels[i] = T::from_superset(&clamped).unwrap_or_else(|| T::from_superset_unchecked(&0.0f32));

// Convert to the quantized type, matching behavior of other operators

out_channels[i] = T::from_superset_unchecked(&requantized);

The from_superset_unchecked() function already implements some safe fallbacks for these edge cases (as you can see from this playground example). Unless you specifically want to fallback to zero in all cases, consider simplifying the validations as suggested by Copilot.

Copilot · 2025-12-28T18:59:02Z

+#[cfg(test)]
+mod tests {
+    use super::*;
+    use quote::ToTokens;


Missing import for TokenBuffer4D. The test uses TokenBuffer4D::new() on line 142 but does not import it. Based on the pattern in other operator test modules (average_pool_2d.rs, conv_2d.rs, depthwise_conv_2d.rs), the import should be added.

Suggested change

use quote::ToTokens;

use quote::ToTokens;

use crate::tensor::TokenBuffer4D;

Correct, this needs to be fixed as it causes the test compilation to fail

Copilot · 2025-12-28T18:59:02Z

+        // Squeeze the coordinates to be within the input tensor's bounds
+        let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);
+        let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);
+
+        // Get the four nearest neighbors
+        let r1 = floorf(in_r_squeezed) as usize;
+        let c1 = floorf(in_c_squeezed) as usize;
+        let r2 = (r1 + 1).min(INPUT_ROWS - 1);
+        let c2 = (c1 + 1).min(INPUT_COLS - 1);
+
+        // Calculate the interpolation weights
+        let yr = in_r_squeezed - r1 as f32;
+        let xr = in_c_squeezed - c1 as f32;


The term "squeezed" is misleading here. These coordinates are being clamped or bounded to the valid input range, not "squeezed" in the mathematical sense. Consider using more precise terminology like "clamped" which better describes the min/max bounding operation.

Suggested change

// Squeeze the coordinates to be within the input tensor's bounds

let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);

let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);

// Get the four nearest neighbors

let r1 = floorf(in_r_squeezed) as usize;

let c1 = floorf(in_c_squeezed) as usize;

let r2 = (r1 + 1).min(INPUT_ROWS - 1);

let c2 = (c1 + 1).min(INPUT_COLS - 1);

// Calculate the interpolation weights

let yr = in_r_squeezed - r1 as f32;

let xr = in_c_squeezed - c1 as f32;

// Clamp the coordinates to be within the input tensor's bounds

let in_r_clamped = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);

let in_c_clamped = in_c.max(0.).min(INPUT_COLS as f32 - 1.);

// Get the four nearest neighbors

let r1 = floorf(in_r_clamped) as usize;

let c1 = floorf(in_c_clamped) as usize;

let r2 = (r1 + 1).min(INPUT_ROWS - 1);

let c2 = (c1 + 1).min(INPUT_COLS - 1);

// Calculate the interpolation weights

let yr = in_r_clamped - r1 as f32;

let xr = in_c_clamped - c1 as f32;

I agree, clamped would be a better name imo

matteocarnelos

Hey, thanks for the contribution! And sorry for the delay in the review.

The addition of this operator seems really useful, however, there are some points I highlighted in the code comments. Also, please make sure that cargo test, cargo clippy, and cargo fmt all pass before we can merge this PR.

matteocarnelos · 2026-04-26T16:01:19Z

+        let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);
+        let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);


Have you considered using the dedicated clamp() function?

Suggested change

let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);

let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);

let in_r_squeezed = in_r.clamp(0., INPUT_ROWS as f32 - 1.);

let in_c_squeezed = in_c.clamp(0., INPUT_COLS as f32 - 1.);

matteocarnelos · 2026-04-26T16:02:24Z

+        // Squeeze the coordinates to be within the input tensor's bounds
+        let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);
+        let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);
+
+        // Get the four nearest neighbors
+        let r1 = floorf(in_r_squeezed) as usize;
+        let c1 = floorf(in_c_squeezed) as usize;
+        let r2 = (r1 + 1).min(INPUT_ROWS - 1);
+        let c2 = (c1 + 1).min(INPUT_COLS - 1);
+
+        // Calculate the interpolation weights
+        let yr = in_r_squeezed - r1 as f32;
+        let xr = in_c_squeezed - c1 as f32;


I agree, clamped would be a better name imo

matteocarnelos · 2026-04-26T16:18:45Z

+            // Validate for NaN/infinity and use safe conversion
+            let clamped = if requantized.is_nan() || requantized.is_infinite() {
+                0.0f32 // Default to zero for invalid results
+            } else {
+                requantized
+            };
+
+            // Use safe conversion with fallback to zero
+            out_channels[i] = T::from_superset(&clamped).unwrap_or_else(|| T::from_superset_unchecked(&0.0f32));


The from_superset_unchecked() function already implements some safe fallbacks for these edge cases (as you can see from this playground example). Unless you specifically want to fallback to zero in all cases, consider simplifying the validations as suggested by Copilot.

matteocarnelos · 2026-04-26T16:22:14Z

+    const CONSTANTS: (f32, f32) = (1.0, 0.0);
+
+    #[test]
+    fn test_upscaling() {


Nitpick: I tend to avoid prepending test_ to test functions as it's quite obvious from the surrounding context and might get wordy when running cargo test. Moreover, consider using the same verb form for all test names:

Suggested change

fn test_upscaling() {

fn upscale() {

matteocarnelos · 2026-04-26T16:22:29Z

+    }
+
+    #[test]
+    fn test_downscaling() {


Suggested change

fn test_downscaling() {

fn downscale() {

matteocarnelos · 2026-04-26T16:26:54Z

+        }
+
+        let input_tensor = tensors.get(inputs.get(0) as usize);
+        let _size_tensor = tensors.get(inputs.get(1) as usize); // Size tensor (target dimensions)


Nitpick: Is this explicitly-ignored variable needed? If not, consider removing it:

Suggested change

let _size_tensor = tensors.get(inputs.get(1) as usize); // Size tensor (target dimensions)

matteocarnelos · 2026-04-26T16:28:19Z

+#[cfg(test)]
+mod tests {
+    use super::*;
+    use quote::ToTokens;


Correct, this needs to be fixed as it causes the test compilation to fail

matteocarnelos · 2026-04-26T16:28:32Z

+    use quote::ToTokens;
+
+    #[test]
+    fn test_to_tokens_i8() {


Suggested change

fn test_to_tokens_i8() {

fn to_tokens_i8() {

matteocarnelos · 2026-04-26T16:28:44Z

+        };
+        assert_eq!(op.to_token_stream().to_string(), expected.to_string());
+    }
+}


Suggested change

}

}

matteocarnelos · 2026-04-26T16:30:40Z

+        _buffers: Vector<ForwardsUOffset<Buffer>>,
+        _index: usize,


Nitpick: Are these explicitly-ignored arguments needed? If not, consider removing them:

Suggested change

_buffers: Vector<ForwardsUOffset<Buffer>>,

_index: usize,

Federico added 2 commits December 27, 2025 00:45

added resize bilinear operator implementation

d6bb986

removed the warning

c1e366c

Copilot AI review requested due to automatic review settings December 28, 2025 18:55

Copilot started reviewing on behalf of federico-pizz December 28, 2025 18:56 View session

Copilot AI reviewed Dec 28, 2025

View reviewed changes

matteocarnelos self-requested a review April 25, 2026 21:23

matteocarnelos assigned federico-pizz Apr 25, 2026

matteocarnelos added the enhancement New feature or request label Apr 25, 2026

matteocarnelos changed the title ~~Resize bilinear operator added~~ Add ResizeBilinear operator Apr 25, 2026

matteocarnelos requested changes Apr 26, 2026

View reviewed changes

matteocarnelos assigned matteocarnelos and unassigned federico-pizz Apr 29, 2026

	use quote::ToTokens;
	use quote::ToTokens;
	use crate::tensor::TokenBuffer4D;

		let in_r_squeezed = in_r.max(0.).min(INPUT_ROWS as f32 - 1.);
		let in_c_squeezed = in_c.max(0.).min(INPUT_COLS as f32 - 1.);

Conversation

federico-pizz commented Dec 28, 2025

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Dec 28, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 28, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 28, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

matteocarnelos left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants