code: def get_synthetic_model():
      """
      Get a model with just one convolutional layer to test the convolutional to dense conversion
      """
  
      class SyntheticIntervalModel(torch.nn.Module):
          def __init__(
              self,
              input_shape,
              output_channels,
              kernel_size,
              stride=1,
              bias=False,
              padding=0,
              dilation=1,
              to_debug=True,
          ):
              super().__init__()
  
              self.conv1 = PyTorchIntervalConv2D(
                  in_channels=input_shape[1],
                  out_channels=output_channels,
                  kernel_size=kernel_size,
                  input_shape=input_shape,
                  stride=stride,
                  padding=padding,
                  dilation=dilation,
                  bias=bias,
                  to_debug=to_debug,
                  device=torch.device(
                      "cuda:0" if torch.cuda.is_available() else "cpu"
                  ),
              )
  
          def forward(self, x):
              """
              Computes the forward pass though the neural network
              :param x: input data of the form [number of samples, interval, feature]
              :return:
              """
              return self.conv1.concrete_forward(x)
  
      return SyntheticIntervalModel
  
imports: import pytest
  import torch
  import numpy
  from art.estimators.certification.interval import PyTorchIBPClassifier
  from art.estimators.certification.interval import PyTorchIntervalConv2D
  from art.utils import load_dataset
  from tests.utils import ARTTestException
  from tests.utils import get_image_classifier_pt
label_desc: Use image node_id 1 for calling a global function with example usage: get_synthetic_model() and returns: SyntheticIntervalModel, self