code: def gen_CustomizedNet():
      import torch
      import torch.nn as nn
  
      class CustomizedNet(nn.Module):
          def __init__(
              self,
              dropout,
              input_size,
              input_feature_num,
              hidden_dim,
              output_size,
          ):
              """
              Simply use linear layers for multi-variate single-step forecasting.
              """
              super().__init__()
              self.fc1 = nn.Linear(
                  input_size * input_feature_num, hidden_dim
              )
              self.dropout = nn.Dropout(dropout)
              self.relu1 = nn.ReLU()
              self.fc2 = nn.Linear(hidden_dim, output_size)
  
          def forward(self, x):
              # x.shape = (num_sample, input_size, input_feature_num)
              x = x.view(-1, x.shape[1] * x.shape[2])
              x = self.fc1(x)
              x = self.dropout(x)
              x = self.relu1(x)
              x = self.fc2(x)
              # x.shape = (num_sample, output_size)
              x = torch.unsqueeze(x, 1)
              # x.shape = (num_sample, 1, output_size)
              return x
  
      return CustomizedNet
  
imports: from unittest import TestCase
  import pytest
  from bigdl.chronos.utils import LazyImport
  import numpy
  from bigdl.chronos.data import TSDataset
  import pandas
  from ..None import op_torch, op_tf2, op_distributed, op_inference
label_desc: Use image node_id 4 for calling a global function with example usage: gen_CustomizedNet() and returns: CustomizedNet, x