def get_efficientdet(checkpoint_path):
config = get_efficientdet_config('efficientdet_d1')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(checkpoint_path)
net.load_state_dict(checkpoint, strict=False)
net = DetBenchPredict(net)
return net
def get_model_detection_efficientdet(model_name,
num_classes,
target_dim,
freeze_batch_norm=False):
print("Using EffDet detection model")
config = effdet.get_efficientdet_config(model_name)
efficientDetModel = EfficientDet(config, pretrained_backbone=False)
load_pretrained(efficientDetModel, config.url)
import omegaconf
with omegaconf.read_write(config):
config.num_classes = num_classes
# config.image_size = target_dim
efficientDetModel.class_net = HeadNet(config, num_outputs=num_classes)
if freeze_batch_norm:
# we only freeze BN layers in backbone and the BiFPN
print("Freezing batch normalization weights")
freeze_bn(efficientDetModel.backbone)
with omegaconf.read_write(efficientDetModel.config):
efficientDetModel.config.num_classes = num_classes
# print(DetBenchTrain(efficientDetModel, config))
return DetBenchTrain(efficientDetModel, config)
def init_settings(self):
""" initialization of data and model variables """
# load nn model
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(
'input/efficientdet/efficientdet_d5-ef44aea8.pth')
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
self.model = DetBenchMulty(net, config)
if args.weights: # load prev weight and continue train process
checkpoint = torch.load(os.path.join(wdir, args.weights))
try:
self.model.load_state_dict(checkpoint['model_state_dict'])
except RuntimeError:
state_dict = torch.load(os.path.join(wdir, args.weights))
# create new OrderedDict that does not contain `module.`
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict['model_state_dict'].items():
name = k[7:] # remove `module.`
new_state_dict[name] = v
# load params
self.model.load_state_dict(new_state_dict)
def __init__(self, model, num_class):
super(EfficientDetCus, self).__init__()
config = get_efficientdet_config(f'tf_efficientdet_{model}')
config.num_classes = num_class
config.image_size = [TRAIN_SIZE, TRAIN_SIZE]
model = EfficientDet(config=config, pretrained_backbone=False)
model.class_net = HeadNet(config, num_outputs=config.num_classes)
self.model = DetBenchTrain(model, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d0')
net = EfficientDet(config, pretrained_backbone=True)
config.num_classes = 14
config.image_size = 512
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load('./input/efficientdet/efficientdet_d5-ef44aea8.pth')
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(r'/content/gdrive/My Drive/Colab Notebooks/globalwheat/input/efficientdet-pytorch-master/efficientdet_d5-ef44aea8.pth')
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('efficientdet_d0')
config.num_classes = 29
config.image_size = [512, 512]
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(
'effdet_checkpoints/2021-02-28 19_55_41/last-checkpoint.pth')
net.load_state_dict(checkpoint['model_state_dict'])
return DetBenchPredict(net)
def get_net(model_name):
config = get_efficientdet_config(model_name)
config.norm_kwargs = dict(eps=.001, momentum=.01)
config.num_classes = 29
# config.image_size = [640, 640]
net = EfficientDet(config, pretrained_backbone=True)
net.class_net = HeadNet(config, num_outputs=config.num_classes)
return DetBenchTrain(net, config)
def model(model_name: str,
num_classes: int,
img_size: int,
pretrained: bool = True) -> nn.Module:
"""Creates the efficientdet model specified by `model_name`.
The model implementation is by Ross Wightman, original repo
[here](https://github.com/rwightman/efficientdet-pytorch).
# Arguments
model_name: Specifies the model to create. For pretrained models, check
[this](https://github.com/rwightman/efficientdet-pytorch#models) table.
num_classes: Number of classes of your dataset (including background).
img_size: Image size that will be fed to the model. Must be squared and
divisible by 64.
pretrained: If True, use a pretrained backbone (on COCO).
# Returns
A PyTorch model.
"""
config = get_efficientdet_config(model_name=model_name)
net = EfficientDet(config, pretrained_backbone=False)
if pretrained:
if not config.url:
raise RuntimeError(f"No pretrained weights for {model_name}")
state_dict = torch.hub.load_state_dict_from_url(
config.url, map_location=torch.device("cpu"))
net.load_state_dict(state_dict)
config.num_classes = num_classes
config.image_size = img_size
net.class_net = HeadNet(
config,
num_outputs=num_classes,
norm_kwargs=dict(eps=0.001, momentum=0.01),
)
# TODO: Break down param groups for backbone
def param_groups_fn(model: nn.Module) -> List[List[nn.Parameter]]:
unwrapped = unwrap_bench(model)
layers = [
unwrapped.backbone,
unwrapped.fpn,
nn.Sequential(unwrapped.class_net, unwrapped.box_net),
]
param_groups = [list(layer.parameters()) for layer in layers]
check_all_model_params_in_groups2(model, param_groups)
return param_groups
model_bench = DetBenchTrain(net, config)
model_bench.param_groups = MethodType(param_groups_fn, model_bench)
return model_bench
def get_net():
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(args["weights_path"])
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = args["image_size"]
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config(Preprocess_config().model)
net = EfficientDet(config, pretrained_backbone=True)
#checkpoint = torch.load('../input/efficientdet/efficientdet_d5-ef44aea8.pth')
#net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 1024
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net(ckpt_path = None):
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
if(ckpt_path !=None):
checkpoint = torch.load('../input/d5-pseudo-aug-best/best-checkpoint-026epoch-2.bin')
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
if(ckpt_path !=None):
net.load_state_dict(checkpoint['model_state_dict'])
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d6')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size = 1024
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load('pretrained/efficientdet_d6-51cb0132.pth')
load_state_dict(net, checkpoint)
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(
'/home/eragon/Documents/scripts/efficientdet-pytorch/checkpoints/tf_efficientdet_d5_51-c79f9be6.pth'
)
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_effdet_train(model_path: str):
config = get_efficientdet_config("tf_efficientdet_d5")
net = EfficientDet(config, pretrained_backbone=False)
checkpoint = torch.load(model_path)
config.num_classes = 1
config.image_size = 512
net.load_state_dict(checkpoint)
net.class_net = HeadNet(
config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=0.001, momentum=0.01),
)
return DetBenchTrain(net, config).train()
def get_net():
config = get_efficientdet_config('tf_efficientdet_d6')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size = 1024
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(
'effdet6-baseline-1024-4x8-sa-fold0/best-checkpoint-052epoch.bin')
load_state_dict(net, checkpoint['model_state_dict'])
return DetBenchTrain(net, config)
def load_train_net(checkpoint_path):
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size = 1024
net.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(checkpoint_path)
net.load_state_dict(checkpoint['model_state_dict'])
return DetBenchTrain(net, config)
def Load_Model(checkpoint_path, which_model='effi5', img_size=1280):
if which_model == 'effi5':
config = get_efficientdet_config(
'tf_efficientdet_d5') # tf_effi5 model structure
elif which_model == 'effi4':
config = get_efficientdet_config(
'tf_efficientdet_d4') # tf_effi4 model structure
elif which_model == 'effi6':
config = get_efficientdet_config(
'tf_efficientdet_d6') # tf_effi4 model structure
config.image_size = (img_size, img_size)
config.num_classes = 32
config.norm_kwargs = dict(eps=.001, momentum=.01)
net = EfficientDet(config, pretrained_backbone=False)
net.class_net = HeadNet(config, num_outputs=config.num_classes)
ckp = torch.load(checkpoint_path)
net.load_state_dict(ckp['model_state_dict'])
del ckp
net = DetBenchPredict(net)
net.eval()
return net
def model(model_name: str,
num_classes: int,
img_size: int,
pretrained: bool = True) -> nn.Module:
""" Creates the model specific by model_name
Args:
model_name (str): Specifies the model to create, available options are: TODO
num_classes (int): Number of classes of your dataset (including background)
pretrained (int): If True, use a pretrained backbone (on COCO)
Returns:
nn.Module: The requested model
"""
config = get_efficientdet_config(model_name=model_name)
net = EfficientDet(config, pretrained_backbone=False)
if pretrained:
if not config.url:
raise RuntimeError(f"No pretrained weights for {model_name}")
state_dict = torch.hub.load_state_dict_from_url(
config.url, map_location=torch.device("cpu"))
net.load_state_dict(state_dict)
config.num_classes = num_classes
config.image_size = img_size
net.class_net = HeadNet(
config,
num_outputs=num_classes,
norm_kwargs=dict(eps=0.001, momentum=0.01),
)
# TODO: Break down param groups for backbone
def param_groups_fn(model: nn.Module) -> List[List[nn.Parameter]]:
unwrapped = unwrap_bench(model)
layers = [
unwrapped.backbone,
unwrapped.fpn,
nn.Sequential(unwrapped.class_net, unwrapped.box_net),
]
param_groups = [list(layer.parameters()) for layer in layers]
check_all_model_params_in_groups2(model, param_groups)
return param_groups
model_bench = DetBenchTrain(net, config)
model_bench.param_groups = MethodType(param_groups_fn, model_bench)
return model_bench
def get_net():
config = get_efficientdet_config('tf_efficientdet_d7')
net = EfficientDet(config, pretrained_backbone=False)
# config.num_classes = 1
# config.image_size = 512
# net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
# checkpoint = torch.load(r'./effdet5-cutmix-augmix1/last-checkpoint-folder1.bin')
# net.load_state_dict(checkpoint['model_state_dict'])
checkpoint = torch.load(r'./tf_efficientdet_d7_53-6d1d7a95.pth')
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
# config.num_classes = 1
# config.image_size = 512
# net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
# checkpoint = torch.load(r'D:\Workspace\efficientdet-pytorch-master\effdet5-cutmix-augmix\last-checkpoint.bin')
# net.load_state_dict(checkpoint['model_state_dict'])
checkpoint = torch.load(r'C:\Users\Aministration\Downloads\efficientdet_d5-ef44aea8.pth')
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_net():
# 模型的配置，这个返回的是一个字典
config = get_efficientdet_config('tf_efficientdet_d5')
config.num_classes = 1
config.image_size = 512
# 根据上面的配置生成网络
net = EfficientDet(config, pretrained_backbone=False)
# 加载gwd预训练模型
checkpoint = torch.load(r'../input/eff_checkpoint/bestv2.bin')
net.load_state_dict(checkpoint['model_state_dict'])
# 加載coco預訓練模型
# norm_kwargs 设置的是 BATCHNORM2D 的参数
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
return DetBenchTrain(net, config)
def get_train_model(config_name='tf_efficientdet_d0', model_ckpt=None):
config = get_efficientdet_config(config_name)
model = EfficientDet(config, pretrained_backbone=True)
#layers_to_train = ['blocks.6','blocks.5', 'blocks.4', 'blocks.3', 'blocks.2', 'blocks.1', 'conv_stem'][:5]
#for name, parameter in model.backbone.named_parameters():
# if all([not name.startswith(layer) for layer in layers_to_train]):
# parameter.requires_grad_(False)
# print(f'layer {name} frozen')
config.num_classes = 1
config.image_size = IMG_SIZE
model.class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
if model_ckpt is not None:
model.load_state_dict(torch.load(model_ckpt)['model_state_dict'])
return DetBenchTrain(model, config)
def get_model_(variant, model_dir):
config = get_efficientdet_config(f"tf_efficientdet_{variant}")
net = EfficientDet(config, pretrained_backbone=False)
# checkpoint = torch.load('/content/wheat_efficientdet/pretrained_models/efficientdet_d0-d92fd44f.pth')
if variant == "d0":
checkpoint_path = f"{model_dir}/efficientdet_d0-d92fd44f.pth"
checkpoint = torch.load(checkpoint_path)
net.load_state_dict(checkpoint)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(
config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=0.001, momentum=0.01),
)
return DetBenchTrain(net, config)
def load_net():
config = get_efficientdet_config('tf_efficientdet_d0')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size=512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(DIR_PATH + '/models/effdet_trained.pth')
net.load_state_dict(checkpoint["model_state_dict"])
del checkpoint
gc.collect()
net = DetBenchEval(net, config)
net.eval();
return net.cuda()
def load_net_eval(checkpoint_path):
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(checkpoint_path, map_location=DEVICE)
net.load_state_dict(checkpoint['model_state_dict'])
del checkpoint
gc.collect()
net = DetBenchEval(net, config)
net.eval()
return net.cuda()
def create_model(num_classes=1,
image_size=512,
architecture="tf_efficientnetv2_l"):
efficientdet_model_param_dict["tf_efficientnetv2_l"] = dict(
name="tf_efficientnetv2_l",
backbone_name="tf_efficientnetv2_l",
backbone_args=dict(drop_path_rate=0.2),
num_classes=num_classes,
url="",
)
config = get_efficientdet_config(architecture)
config.update({"num_classes": num_classes})
config.update({"image_size": (image_size, image_size)})
net = EfficientDet(config, pretrained_backbone=True)
net.class_net = HeadNet(
config,
num_outputs=config.num_classes,
)
return DetBenchTrain(net, config)
def __init__(self,
num_classes=det_config.NUM_CLASSES,
image_size=det_config.H,
pretrained=det_config.DET_PRETRAINED):
super(EfficientDetection, self).__init__()
self.config = get_efficientdet_config('tf_efficientdet_d5')
self.net = EfficientDet(self.config, pretrained_backbone=pretrained)
self.config.num_classes = num_classes
self.config.image_size = image_size
self.net.class_net = HeadNet(self.config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
def get_model_instance_segmentation_efficientnet(model_name,
num_classes,
target_dim,
freeze_batch_norm=False):
print("Using EffDet detection model")
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],
output_size=7,
sampling_ratio=2)
# ofekp: note that roi_pooler is passed to box_roi_pooler in the MaskRCNN network
# and is not being used in roi_heads.py
mask_roi_pool = MultiScaleRoIAlign(featmap_names=[0, 1, 2, 3],
output_size=14,
sampling_ratio=2)
config = effdet.get_efficientdet_config(model_name)
efficientDetModelTemp = EfficientDet(config, pretrained_backbone=False)
load_pretrained(efficientDetModelTemp, config.url)
config.num_classes = num_classes
config.image_size = target_dim
out_channels = config.fpn_channels # This is since the config of 'tf_efficientdet_d5' creates fpn outputs with num of channels = 288
backbone_fpn = BackboneWithCustomFPN(
config, efficientDetModelTemp.backbone, efficientDetModelTemp.fpn,
out_channels
) # TODO(ofekp): pretrained! # from the repo trainable_layers=trainable_backbone_layers=3
model = MaskRCNN(
backbone_fpn,
min_size=target_dim,
max_size=target_dim,
num_classes=num_classes,
mask_roi_pool=mask_roi_pool,
# rpn_anchor_generator=anchor_generator,
box_roi_pool=roi_pooler)
# for training with different number of classes (default is 90) we need to add this line
# TODO(ofekp): we might want to init weights of the new HeadNet
class_net = HeadNet(config,
num_outputs=config.num_classes,
norm_kwargs=dict(eps=.001, momentum=.01))
efficientDetModel = EfficientDetBB(config, class_net,
efficientDetModelTemp.box_net)
model.roi_heads.box_predictor = DetBenchTrain(efficientDetModel, config)
if freeze_batch_norm:
# we only freeze BN layers in backbone and the BiFPN
print("Freezing batch normalization weights")
freeze_bn(model.backbone)
return model
