Refactor textnet model

src/transformers/models/textnet/configuration_textnet.py

@@ -34,42 +34,42 @@ class TextNetConfig(BackboneConfigMixin, PretrainedConfig):
 
     def __init__(
         self,
-        backbone_kernel_size=3,
-        backbone_stride=2,
-        backbone_dilation=1,
-        backbone_groups=1,
-        backbone_bias=False,
-        backbone_has_shuffle=False,
-        backbone_in_channels=3,
-        backbone_out_channels=64,
-        backbone_use_bn=True,
-        backbone_act_func="relu",
-        backbone_dropout_rate=0,
-        backbone_ops_order="weight_bn_act",
-        backbone_stage1_in_channels=[64, 64, 64],
-        backbone_stage1_out_channels=[64, 64, 64],
-        backbone_stage1_kernel_size=[[3, 3], [3, 3], [3, 3]],
-        backbone_stage1_stride=[1, 2, 1],
-        backbone_stage1_dilation=[1, 1, 1],
-        backbone_stage1_groups=[1, 1, 1],
-        backbone_stage2_in_channels=[64, 128, 128, 128],
-        backbone_stage2_out_channels=[128, 128, 128, 128],
-        backbone_stage2_kernel_size=[[3, 3], [1, 3], [3, 3], [3, 1]],
-        backbone_stage2_stride=[2, 1, 1, 1],
-        backbone_stage2_dilation=[1, 1, 1, 1],
-        backbone_stage2_groups=[1, 1, 1, 1],
-        backbone_stage3_in_channels=[128, 256, 256, 256],
-        backbone_stage3_out_channels=[256, 256, 256, 256],
-        backbone_stage3_kernel_size=[[3, 3], [3, 3], [3, 1], [1, 3]],
-        backbone_stage3_stride=[2, 1, 1, 1],
-        backbone_stage3_dilation=[1, 1, 1, 1],
-        backbone_stage3_groups=[1, 1, 1, 1],
-        backbone_stage4_in_channels=[256, 512, 512, 512],
-        backbone_stage4_out_channels=[512, 512, 512, 512],
-        backbone_stage4_kernel_size=[[3, 3], [3, 1], [1, 3], [3, 3]],
-        backbone_stage4_stride=[2, 1, 1, 1],
-        backbone_stage4_dilation=[1, 1, 1, 1],
-        backbone_stage4_groups=[1, 1, 1, 1],
+        kernel_size=3,
+        stride=2,
+        dilation=1,
+        groups=1,
+        bias=False,
+        has_shuffle=False,
+        in_channels=3,
+        out_channels=64,
+        use_bn=True,
+        act_func="relu",
+        dropout_rate=0,
+        ops_order="weight_bn_act",
+        stage1_in_channels=[64, 64, 64],
+        stage1_out_channels=[64, 64, 64],
+        stage1_kernel_size=[[3, 3], [3, 3], [3, 3]],
+        stage1_stride=[1, 2, 1],
+        stage1_dilation=[1, 1, 1],
+        stage1_groups=[1, 1, 1],
+        stage2_in_channels=[64, 128, 128, 128],
+        stage2_out_channels=[128, 128, 128, 128],
+        stage2_kernel_size=[[3, 3], [1, 3], [3, 3], [3, 1]],
+        stage2_stride=[2, 1, 1, 1],
+        stage2_dilation=[1, 1, 1, 1],
+        stage2_groups=[1, 1, 1, 1],
+        stage3_in_channels=[128, 256, 256, 256],
+        stage3_out_channels=[256, 256, 256, 256],
+        stage3_kernel_size=[[3, 3], [3, 3], [3, 1], [1, 3]],
+        stage3_stride=[2, 1, 1, 1],
+        stage3_dilation=[1, 1, 1, 1],
+        stage3_groups=[1, 1, 1, 1],
+        stage4_in_channels=[256, 512, 512, 512],
+        stage4_out_channels=[512, 512, 512, 512],
+        stage4_kernel_size=[[3, 3], [3, 1], [1, 3], [3, 3]],
+        stage4_stride=[2, 1, 1, 1],
+        stage4_dilation=[1, 1, 1, 1],
+        stage4_groups=[1, 1, 1, 1],
         hidden_sizes=[64, 64, 128, 256, 512],
         initializer_range=0.02,
         out_features=None,
@@ -78,55 +78,55 @@ def __init__(
     ):
         super().__init__(**kwargs)
 
-        self.backbone_kernel_size = backbone_kernel_size
-        self.backbone_stride = backbone_stride
-        self.backbone_dilation = backbone_dilation
-        self.backbone_groups = backbone_groups
-        self.backbone_bias = backbone_bias
-        self.backbone_has_shuffle = backbone_has_shuffle
-        self.backbone_in_channels = backbone_in_channels
-        self.backbone_out_channels = backbone_out_channels
-        self.backbone_use_bn = backbone_use_bn
-        self.backbone_act_func = backbone_act_func
-        self.backbone_dropout_rate = backbone_dropout_rate
-        self.backbone_ops_order = backbone_ops_order
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+        self.groups = groups
+        self.bias = bias
+        self.has_shuffle = has_shuffle
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.use_bn = use_bn
+        self.act_func = act_func
+        self.dropout_rate = dropout_rate
+        self.ops_order = ops_order
 
-        self.backbone_stage1_in_channels = backbone_stage1_in_channels
-        self.backbone_stage1_out_channels = backbone_stage1_out_channels
-        self.backbone_stage1_kernel_size = backbone_stage1_kernel_size
-        self.backbone_stage1_stride = backbone_stage1_stride
-        self.backbone_stage1_dilation = backbone_stage1_dilation
-        self.backbone_stage1_groups = backbone_stage1_groups
+        self.stage1_in_channels = stage1_in_channels
+        self.stage1_out_channels = stage1_out_channels
+        self.stage1_kernel_size = stage1_kernel_size
+        self.stage1_stride = stage1_stride
+        self.stage1_dilation = stage1_dilation
+        self.stage1_groups = stage1_groups
 
-        self.backbone_stage2_in_channels = backbone_stage2_in_channels
-        self.backbone_stage2_out_channels = backbone_stage2_out_channels
-        self.backbone_stage2_kernel_size = backbone_stage2_kernel_size
-        self.backbone_stage2_stride = backbone_stage2_stride
-        self.backbone_stage2_dilation = backbone_stage2_dilation
-        self.backbone_stage2_groups = backbone_stage2_groups
+        self.stage2_in_channels = stage2_in_channels
+        self.stage2_out_channels = stage2_out_channels
+        self.stage2_kernel_size = stage2_kernel_size
+        self.stage2_stride = stage2_stride
+        self.stage2_dilation = stage2_dilation
+        self.stage2_groups = stage2_groups
 
-        self.backbone_stage3_in_channels = backbone_stage3_in_channels
-        self.backbone_stage3_out_channels = backbone_stage3_out_channels
-        self.backbone_stage3_kernel_size = backbone_stage3_kernel_size
-        self.backbone_stage3_stride = backbone_stage3_stride
-        self.backbone_stage3_dilation = backbone_stage3_dilation
-        self.backbone_stage3_groups = backbone_stage3_groups
+        self.stage3_in_channels = stage3_in_channels
+        self.stage3_out_channels = stage3_out_channels
+        self.stage3_kernel_size = stage3_kernel_size
+        self.stage3_stride = stage3_stride
+        self.stage3_dilation = stage3_dilation
+        self.stage3_groups = stage3_groups
 
-        self.backbone_stage4_in_channels = backbone_stage4_in_channels
-        self.backbone_stage4_out_channels = backbone_stage4_out_channels
-        self.backbone_stage4_kernel_size = backbone_stage4_kernel_size
-        self.backbone_stage4_stride = backbone_stage4_stride
-        self.backbone_stage4_dilation = backbone_stage4_dilation
-        self.backbone_stage4_groups = backbone_stage4_groups
+        self.stage4_in_channels = stage4_in_channels
+        self.stage4_out_channels = stage4_out_channels
+        self.stage4_kernel_size = stage4_kernel_size
+        self.stage4_stride = stage4_stride
+        self.stage4_dilation = stage4_dilation
+        self.stage4_groups = stage4_groups
 
         self.initializer_range = initializer_range
         self.hidden_sizes = hidden_sizes
 
         self.depths = [
-            len(self.backbone_stage1_out_channels),
-            len(self.backbone_stage2_out_channels),
-            len(self.backbone_stage3_out_channels),
-            len(self.backbone_stage4_out_channels),
+            len(self.stage1_out_channels),
+            len(self.stage2_out_channels),
+            len(self.stage3_out_channels),
+            len(self.stage4_out_channels),
         ]
         self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, 5)]
         self._out_features, self._out_indices = get_aligned_output_features_output_indices(

src/transformers/models/textnet/modeling_textnet.py

@@ -363,63 +363,63 @@ class TextNetModel(TextNetPreTrainedModel):
     def __init__(self, config):
         super().__init__(config)
         self.first_conv = TextNetConvLayer(
-            config.backbone_in_channels,
-            config.backbone_out_channels,
-            config.backbone_kernel_size,
-            config.backbone_stride,
-            config.backbone_dilation,
-            config.backbone_groups,
-            config.backbone_bias,
-            config.backbone_has_shuffle,
-            config.backbone_use_bn,
-            config.backbone_act_func,
-            config.backbone_dropout_rate,
-            config.backbone_ops_order,
+            config.in_channels,
+            config.out_channels,
+            config.kernel_size,
+            config.stride,
+            config.dilation,
+            config.groups,
+            config.bias,
+            config.has_shuffle,
+            config.use_bn,
+            config.act_func,
+            config.dropout_rate,
+            config.ops_order,
         )
         stage1 = []
         for stage_config in zip(
-            config.backbone_stage1_in_channels,
-            config.backbone_stage1_out_channels,
-            config.backbone_stage1_kernel_size,
-            config.backbone_stage1_stride,
-            config.backbone_stage1_dilation,
-            config.backbone_stage1_groups,
+            config.stage1_in_channels,
+            config.stage1_out_channels,
+            config.stage1_kernel_size,
+            config.stage1_stride,
+            config.stage1_dilation,
+            config.stage1_groups,
         ):
             stage1.append(TestNetRepConvLayer(*stage_config))
         self.stage1 = nn.ModuleList(stage1)
 
         stage2 = []
         for stage_config in zip(
-            config.backbone_stage2_in_channels,
-            config.backbone_stage2_out_channels,
-            config.backbone_stage2_kernel_size,
-            config.backbone_stage2_stride,
-            config.backbone_stage2_dilation,
-            config.backbone_stage2_groups,
+            config.stage2_in_channels,
+            config.stage2_out_channels,
+            config.stage2_kernel_size,
+            config.stage2_stride,
+            config.stage2_dilation,
+            config.stage2_groups,
         ):
             stage2.append(TestNetRepConvLayer(*stage_config))
         self.stage2 = nn.ModuleList(stage2)
 
         stage3 = []
         for stage_config in zip(
-            config.backbone_stage3_in_channels,
-            config.backbone_stage3_out_channels,
-            config.backbone_stage3_kernel_size,
-            config.backbone_stage3_stride,
-            config.backbone_stage3_dilation,
-            config.backbone_stage3_groups,
+            config.stage3_in_channels,
+            config.stage3_out_channels,
+            config.stage3_kernel_size,
+            config.stage3_stride,
+            config.stage3_dilation,
+            config.stage3_groups,
         ):
             stage3.append(TestNetRepConvLayer(*stage_config))
         self.stage3 = nn.ModuleList(stage3)
 
         stage4 = []
         for stage_config in zip(
-            config.backbone_stage4_in_channels,
-            config.backbone_stage4_out_channels,
-            config.backbone_stage4_kernel_size,
-            config.backbone_stage4_stride,
-            config.backbone_stage4_dilation,
-            config.backbone_stage4_groups,
+            config.stage4_in_channels,
+            config.stage4_out_channels,
+            config.stage4_kernel_size,
+            config.stage4_stride,
+            config.stage4_dilation,
+            config.stage4_groups,
         ):
             stage4.append(TestNetRepConvLayer(*stage_config))
         self.stage4 = nn.ModuleList(stage4)
@@ -481,11 +481,11 @@ def __init__(self, config):
 
         self.textnet = TextNetModel(config)
         self.num_features = [
-            config.backbone_out_channels,
-            config.backbone_stage1_out_channels[-1],
-            config.backbone_stage2_out_channels[-1],
-            config.backbone_stage3_out_channels[-1],
-            config.backbone_stage4_out_channels[-1],
+            config.out_channels,
+            config.stage1_out_channels[-1],
+            config.stage2_out_channels[-1],
+            config.stage3_out_channels[-1],
+            config.stage4_out_channels[-1],
         ]
 
         # initialize weights and apply final processing