code: def test_activation():
      """Activation"""
  
      class Softmax(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Softmax()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class Softplus(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Softplus()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class Softsign(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Softsign()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class Tanh(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Tanh()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class ReLU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.ReLU()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class ReLU6(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.ReLU6()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class PReLU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.PReLU()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class SELU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.SELU()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class SiLU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.SiLU()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class LeakyReLU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.LeakyReLU(0.1)
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class GELU(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.GELU()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class HardTanh(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Hardtanh()
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      class TensorSoftmax(flow.nn.Module):
          def forward(self, x):
              x = x.softmax(dim=-1)
              return x
  
      class Threshold(flow.nn.Module):
          def __init__(self):
              super().__init__()
              self.active = flow.nn.Threshold(0.5, 0.2)
  
          def forward(self, x):
              x = self.active(x)
              return x
  
      if os.path.exists(MODEL_HOME):
          rmdir(MODEL_HOME)
  
      model1 = Softmax().eval()
      model2 = Softplus().eval()  # pylint: disable=unused-variable
      model3 = Softsign().eval()
      model4 = Tanh().eval()
      model5 = ReLU().eval()
      model6 = ReLU6().eval()
      model7 = PReLU().eval()
      model8 = SELU().eval()
      model9 = SiLU().eval()
      model10 = LeakyReLU().eval()
      model11 = GELU().eval()
      model12 = HardTanh().eval()
      model13 = TensorSoftmax().eval()
  
      for device in ["llvm"]:
          verify_activation(model1, device=device)
          verify_activation(model2, device=device)
          verify_activation(model3, device=device)
          verify_activation(model4, device=device)
          verify_activation(model5, device=device)
          verify_activation(model6, device=device)
          verify_activation(model7, device=device)
          verify_activation(model8, device=device)
          verify_activation(model9, device=device)
          verify_activation(model10, device=device)
          verify_activation(model11, device=device)
          verify_activation(model12, device=device)
          verify_activation(
              model13,
              device=device,
              inputs=flow.tensor(
                  np.random.rand(1, 12, 197, 197).astype(np.float32)
              ),
          )
  
      # Threshold was introduced in the version 0.8.0 of oneflow
      if package_version.parse(
          flow.__version__
      ) >= package_version.parse("0.8.0"):
          model14 = Threshold().eval()
          verify_activation(model14, device="llvm")
  
imports: import os
  import numpy
  import oneflow
  from packaging import version
  import tvm
  import tvm.testing
  import tvm.topi.testing
  from tvm import relay
label_desc: Use image node_id 24 for calling a global function with example usage: test_activation() and returns: x, x, x, x, x, x, x, x, x, x, x, x, x, x