def init()

in PyTorchClassification/models.py [0:0]
103 lines of code
23 McCabe index (conditional complexity)

    def init(self, model_type, classnames, image_sizes, loadImagenetWeights=True):

        self.model_type = model_type
        num_classes = len(classnames)
        self.classnames = classnames
        pretrained = loadPretrained = "imagenet" if loadImagenetWeights else None

        if self.model_type == ModelType.inceptionv3:
            model = pretrained.inceptionv3.inception_v3(num_classes=num_classes, 
                               pretrained=loadPretrained, aux_logits=False)
            model.last_linear = model.fc

        elif (self.model_type == ModelType.inceptionv4):
            model = pretrainedmodels.__dict__["inceptionv4"](num_classes=1000, pretrained=loadPretrained)
            ct = 0
            for child in model.children():
                for param in child.parameters():
                    param.requires_grad = True
                ct += 1
            model.avg_pool = nn.AdaptiveAvgPool2d((1,1))
            model.last_linear = nn.Linear(model.last_linear.in_features, num_classes)    

        elif (self.model_type == ModelType.inceptionresnetv2):

            model = pretrainedmodels.__dict__["inceptionresnetv2"](num_classes=1000, pretrained=loadPretrained)
        
            ct = 0
            for child in model.children():
                for param in child.parameters():
                    param.requires_grad = True
                ct += 1
            model.avgpool_1a = nn.AdaptiveAvgPool2d((1,1))
            model.last_linear = nn.Linear(model.last_linear.in_features, num_classes)    

        elif (self.model_type == ModelType.resnext101):
            model = pretrainedmodels.__dict__["se_resnext101_32x4d"](num_classes=1000, pretrained=loadPretrained)
            model.avg_pool = nn.AdaptiveAvgPool2d((1,1))
            model.last_linear = nn.Linear(model.last_linear.in_features, num_classes)    

        elif (self.model_type == ModelType.resnet50):
            model = models.resnet50(pretrained=True)
        
            ct = 0
            for child in model.children():
                for param in child.parameters():
                    param.requires_grad = False
                ct += 1

            model.fc  = nn.Linear(model.fc.in_features, num_classes)

        elif (self.model_type == ModelType.inceptionv4_inceptionresnetv2):
            modelIncept = pretrainedmodels.__dict__["inceptionv4"](num_classes=1000, pretrained=loadPretrained)
            modelResnet = pretrainedmodels.__dict__["inceptionresnetv2"](num_classes=1000, pretrained=loadPretrained)

            '''
            ct = 0
            for child in modelIncept.children():
                #print("Child %d %s" % (ct, child))
                if (ct < 19):
                    for param in child.parameters():
                        param.requires_grad = False
                else:
                    for param in child.parameters():
                        param.requires_grad = False
                ct += 1

            ct = 0
            for child in modelResnet.children():
                #print("Child %d %s" % (ct, child))
                if (ct < 11):
                    for param in child.parameters():
                        param.requires_grad = False
                else:
                    for param in child.parameters():
                        param.requires_grad = False
                ct += 1
            '''
            modelIncept.avg_pool = nn.AdaptiveAvgPool2d((1,1))
            modelResnet.avgpool_1a = nn.AdaptiveAvgPool2d((1,1))
            modelIncept.last_linear = nn.Linear(modelIncept.last_linear.in_features, num_classes)    
            modelResnet.last_linear = nn.Linear(modelResnet.last_linear.in_features, num_classes)   
            
            model = EnsembleAverage(modelIncept, modelResnet, num_classes, self.image_sizes)

        elif (self.model_type == ModelType.inceptionv4_resnext101):
            modelIncept = pretrainedmodels.__dict__["inceptionv4"](num_classes=1000, pretrained="imagenet")
            modelIncept.avg_pool = nn.AdaptiveAvgPool2d((1,1))
            modelIncept.last_linear = nn.Linear(modelIncept.last_linear.in_features, num_classes)
    
            modelResnet = pretrainedmodels.__dict__["se_resnext101_32x4d"](num_classes=1000, pretrained="imagenet")
            modelResnet.avg_pool = nn.AdaptiveAvgPool2d((1,1))
            modelResnet.last_linear = nn.Linear(modelResnet.last_linear.in_features, num_classes)    

            model = EnsembleAverage(modelIncept, modelResnet, num_classes, self.image_sizes)

        else: #if (self.model_type == Model.inceptionv4_resnet50):
            modelIncept = pretrainedmodels.__dict__["inceptionv4"](num_classes=1000, pretrained=loadPretrained)        
            modelResnet = models.resnet50(pretrained=True)

            ct = 0
            for child in modelIncept.children():
                #print("Child %d %s" % (ct, child))
                if (ct < 19):
                    for param in child.parameters():
                        param.requires_grad = False
                else:
                    for param in child.parameters():
                        param.requires_grad = False
                ct += 1

            ct = 0
            for child in modelResnet.children():
                #print("Child %d %s" % (ct, child))
                if (ct < 11):
                    for param in child.parameters():
                        param.requires_grad = False
                else:
                    for param in child.parameters():
                        param.requires_grad = False
                ct += 1

            modelIncept.last_linear = nn.Linear(modelIncept.last_linear.in_features, num_classes)    
            modelResnet.fc  = nn.Linear(modelResnet.fc.in_features, num_classes)

            model = EnsembleAverage(modelIncept, modelResnet, num_classes)

        self.model = model
        self.loader = ImageLoader(self.image_sizes)