making efficientnet own class that efficientnetconfig calls

app.py

@@ -85,11 +85,11 @@ def get_activations(model, image: list, model_name: str,
     
     
     layer_outputs = {}
-    for i in range(len(model.features)):
-        image = model.features[i](image)
+    for i in range(len(model.model.features)):
+        image = model.model.features[i](image)
         layer_outputs[i] = image
         print(i, layer_outputs[i].shape)
-    output = model(image).detach().cpu().numpy()
+    output = model.model(image).detach().cpu().numpy()
     output_1 = activation_indices[model_name].detach().cpu().numpy()
     output_2 = activation_indices[model_name].detach().cpu().numpy()
     

model_utils/efficientnet_config.py

@@ -269,8 +269,170 @@ class EfficientNetConfig(PretrainedConfig):
             norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use
             last_channel (int): The number of channels on the penultimate layer
         """
+        
+        
+        self.model = EfficientNet(
+                                    dropout,
+                                    num_channels=num_channels,
+                                    num_classes=num_classes,
+                                    size=size,
+                                    stochastic_depth_prob=stochastic_depth_prob,
+                                    width_mult=width_mult,
+                                    depth_mult=depth_mult,
+        )
+        
+        super().__init__(**kwargs)
+        
         # super().__init__()
         # _log_api_usage_once(self)
+        # inverted_residual_setting, last_channel = _efficientnet_conf(
+        #              "efficientnet_%s" % (size), width_mult=width_mult, depth_mult=depth_mult
+        #             )
+
+        # if not inverted_residual_setting:
+        #     raise ValueError("The inverted_residual_setting should not be empty")
+        # elif not (
+        #     isinstance(inverted_residual_setting, Sequence)
+        #     and all([isinstance(s, _MBConvConfig) for s in inverted_residual_setting])
+        # ):
+        #     raise TypeError(
+        #         "The inverted_residual_setting should be List[MBConvConfig]"
+        #     )
+
+        # if "block" in kwargs:
+        #     warnings.warn(
+        #         "The parameter 'block' is deprecated since 0.13 and will be removed 0.15. "
+        #         "Please pass this information on 'MBConvConfig.block' instead."
+        #     )
+        #     if kwargs["block"] is not None:
+        #         for s in inverted_residual_setting:
+        #             if isinstance(s, MBConvConfig):
+        #                 s.block = kwargs["block"]
+
+        # if norm_layer is None:
+        #     norm_layer = nn.BatchNorm2d
+
+        # layers: List[nn.Module] = []
+
+        # # building first layer
+        # firstconv_output_channels = inverted_residual_setting[0].input_channels
+        # layers.append(
+        #     Conv2dNormActivation(
+        #         num_channels,
+        #         firstconv_output_channels,
+        #         kernel_size=3,
+        #         stride=2,
+        #         norm_layer=norm_layer,
+        #         activation_layer=nn.SiLU,
+        #     )
+        # )
+
+        # # building inverted residual blocks
+        # total_stage_blocks = sum(cnf.num_layers for cnf in inverted_residual_setting)
+        # stage_block_id = 0
+        # for cnf in inverted_residual_setting:
+        #     stage: List[nn.Module] = []
+        #     for _ in range(cnf.num_layers):
+        #         # copy to avoid modifications. shallow copy is enough
+        #         block_cnf = copy.copy(cnf)
+
+        #         # overwrite info if not the first conv in the stage
+        #         if stage:
+        #             block_cnf.input_channels = block_cnf.out_channels
+        #             block_cnf.stride = 1
+
+        #         # adjust stochastic depth probability based on the depth of the stage block
+        #         sd_prob = (
+        #             stochastic_depth_prob * float(stage_block_id) / total_stage_blocks
+        #         )
+
+        #         stage.append(block_cnf.block(block_cnf, sd_prob, norm_layer))
+        #         stage_block_id += 1
+
+        #     layers.append(nn.Sequential(*stage))
+
+        # # building last several layers
+        # lastconv_input_channels = inverted_residual_setting[-1].out_channels
+        # lastconv_output_channels = (
+        #     last_channel if last_channel is not None else 4 * lastconv_input_channels
+        # )
+        # layers.append(
+        #     Conv2dNormActivation(
+        #         lastconv_input_channels,
+        #         lastconv_output_channels,
+        #         kernel_size=1,
+        #         norm_layer=norm_layer,
+        #         activation_layer=nn.SiLU,
+        #     )
+        # )
+
+        # self.features = nn.Sequential(*layers)
+        # self.avgpool = nn.AdaptiveAvgPool2d(1)
+        # self.classifier = nn.Sequential(
+        #     nn.Dropout(p=dropout, inplace=True),
+        #     nn.Linear(lastconv_output_channels, num_classes),
+        # )
+
+        # for m in self.modules():
+    #         if isinstance(m, nn.Conv2d):
+    #             nn.init.kaiming_normal_(m.weight, mode="fan_out")
+    #             if m.bias is not None:
+    #                 nn.init.zeros_(m.bias)
+    #         elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+    #             nn.init.ones_(m.weight)
+    #             nn.init.zeros_(m.bias)
+    #         elif isinstance(m, nn.Linear):
+    #             init_range = 1.0 / math.sqrt(m.out_features)
+    #             nn.init.uniform_(m.weight, -init_range, init_range)
+    #             nn.init.zeros_(m.bias)
+                
+    #     super().__init__(**kwargs)
+
+    # def _forward_impl(self, x: Tensor) -> Tensor:
+    #     x = self.features(x)
+
+    #     x = self.avgpool(x)
+    #     x = torch.flatten(x, 1)
+
+    #     x = self.classifier(x)
+
+    #     return x
+
+    # def forward(self, x: Tensor) -> Tensor:
+    #     return self._forward_impl(x)
+    
+    
+class EfficientNet(nn.Module):
+    
+    model_type = "efficientnet"
+    
+    def __init__(
+        self,
+        # inverted_residual_setting: Sequence[Union[MBConvConfig, FusedMBConvConfig]],
+        dropout: float,
+        num_channels: int = 61,
+        stochastic_depth_prob: float = 0.2,
+        num_classes: int = 2,
+        norm_layer: Optional[Callable[..., nn.Module]] = None,
+        # last_channel: Optional[int] = None,
+        size: str='v2_s',
+        width_mult: float = 1.0,
+        depth_mult: float = 1.0,
+        **kwargs: Any,
+    ) -> None:
+        """
+        EfficientNet V1 and V2 main class
+
+        Args:
+            inverted_residual_setting (Sequence[Union[MBConvConfig, FusedMBConvConfig]]): Network structure
+            dropout (float): The droupout probability
+            stochastic_depth_prob (float): The stochastic depth probability
+            num_classes (int): Number of classes
+            norm_layer (Optional[Callable[..., nn.Module]]): Module specifying the normalization layer to use
+            last_channel (int): The number of channels on the penultimate layer
+        """
+        super().__init__()
+        # _log_api_usage_once(self)
         
         inverted_residual_setting, last_channel = _efficientnet_conf(
                      "efficientnet_%s" % (size), width_mult=width_mult, depth_mult=depth_mult
@@ -373,7 +535,7 @@ class EfficientNetConfig(PretrainedConfig):
                 nn.init.uniform_(m.weight, -init_range, init_range)
                 nn.init.zeros_(m.bias)
                 
-        super().__init__(**kwargs)
+        # super().__init__(**kwargs)
 
     def _forward_impl(self, x: Tensor) -> Tensor:
         x = self.features(x)