code: def export_gridsample_mode_aligncorners() -> None:
      # X shape, [N, C, H, W] - [1, 1, 3, 2]
      X = np.array(
          [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
          dtype=np.float32,
      )
      # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
      Grid = np.array(
          [
              [
                  [
                      [-1.0000, -1.0000],
                      [-0.5000, -0.5000],
                      [-0.2000, -0.2000],
                      [0.0000, 0.0000],
                  ],
                  [
                      [0.0000, 0.0000],
                      [-0.2000, -0.2000],
                      [0.5000, 0.5000],
                      [1.0000, 1.0000],
                  ],
              ]
          ],
          dtype=np.float32,
      )
  
      # setting mode = 'bilinear', default align_corners = 0
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="linear",
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bilinear = np.array(
          [
              [
                  [
                      [0.0000, 0.5000, 1.7000, 2.5000],
                      [2.5000, 1.7000, 4.5000, 1.2500],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bilinear],
          name="test_gridsample_bilinear",
      )
  
      # setting mode = 'bilinear', align_corners = 1
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="linear",
          align_corners=1,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_align_corners = np.array(
          [
              [
                  [
                      [0.0000, 1.2500, 2.0000, 2.5000],
                      [2.5000, 2.0000, 3.7500, 5.0000],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_align_corners],
          name="test_gridsample_aligncorners_true",
      )
  
      # setting mode = 'nearest'
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="nearest",
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_nearest = np.array(
          [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_nearest],
          name="test_gridsample_nearest",
      )
  
      # setting mode = 'bicubic'
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="cubic",
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bicubic = np.array(
          [
              [
                  [
                      [-0.1406, 0.3828, 1.7556, 2.9688],
                      [2.9688, 1.7556, 5.1445, 1.3906],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bicubic],
          name="test_gridsample_bicubic",
      )
  
      # ============================================================================
      # Additional tests
      # The reference output tensors were generated using PyTorch 2.0.
      Grid = np.array(
          [
              [
                  [
                      [-1.0, -0.8],
                      [-0.6, -0.5],
                      [-0.1, -0.2],
                      [0.7, 0.0],
                  ],
                  [[0.0, 0.4], [0.2, -0.2], [-0.3, 0.5], [-1.0, 1.0]],
              ]
          ],
          dtype=np.float32,
      )
  
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="nearest",
          align_corners=0,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_nearest = np.array(
          [[[[0.0, 0.0, 2.0, 3.0], [4.0, 3.0, 4.0, 4.0]]]],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_nearest],
          name="test_gridsample_nearest_align_corners_0_additional_1",
      )
  
      # setting mode = 'nearest'
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="nearest",
          align_corners=1,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_nearest = np.array(
          [[[[0.0, 0.0, 2.0, 3.0], [2.0, 3.0, 4.0, 4.0]]]],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_nearest],
          name="test_gridsample_nearest_align_corners_1_additional_1",
      )
  
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="linear",
          align_corners=0,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bilinear = np.array(
          [
              [
                  [
                      [0.0000, 0.4500, 1.8000, 2.4000],
                      [3.7000, 2.1000, 3.7000, 1.0000],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bilinear],
          name="test_gridsample_bilinear_align_corners_0_additional_1",
      )
  
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="linear",
          align_corners=1,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bilinear = np.array(
          [
              [
                  [
                      [0.4000, 1.2000, 2.0500, 2.8500],
                      [3.3000, 2.2000, 3.3500, 4.0000],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bilinear],
          name="test_gridsample_bilinear_align_corners_1_additional_1",
      )
  
      # These two new bicubic tests produces slightly higher error ~5e-5
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="cubic",
          align_corners=0,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bicubic = np.array(
          [
              [
                  [
                      [-0.173250, 0.284265, 1.923106, 2.568000],
                      [5.170375, 2.284414, 4.744844, 1.046875],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bicubic],
          name="test_gridsample_bicubic_align_corners_0_additional_1",
      )
  
      node = onnx.helper.make_node(
          "GridSample",
          inputs=["X", "Grid"],
          outputs=["Y"],
          mode="cubic",
          align_corners=1,
      )
      # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
      Y_bicubic = np.array(
          [
              [
                  [
                      [0.304001, 1.128750, 2.266270, 3.144844],
                      [4.531500, 2.455360, 4.599819, 4.000000],
                  ]
              ]
          ],
          dtype=np.float32,
      )
  
      expect(
          node,
          inputs=[X, Grid],
          outputs=[Y_bicubic],
          name="test_gridsample_bicubic_align_corners_1_additional_1",
      )
  
file_path: onnx/onnx/backend/test/case/node/gridsample.py
imports: import numpy
  import onnx
  from onnx.backend.test.case.base import Base
  from onnx.backend.test.case.node import expect
label_desc: Use image node_id 3 for calling the GridSample obj's underlying member method code with example usage: obj.export_gridsample_mode_aligncorners() without return types