def test_chicken(self):
chicken_img = Image.open(
pathlib.Path(__file__).parent / 'efficientnet/Chicken.jpg')
model = EfficientNet(number=0)
model.load_from_pretrained()
label = _infer(model, chicken_img)
self.assertEqual(label, "hen",
f"Expected hen but got {label} for number=0")
def EfficientNet_B8(pretrained=True, num_class=5, onehot=1, onehot2=0):
if pretrained:
model = EfficientNet.from_pretrained('efficientnet-b8', num_classes=num_class, onehot=onehot, onehot2=onehot2)
for name, param in model.named_parameters():
if 'fc' not in name:
param.requires_grad = False
else:
model = EfficientNet.from_name('efficientnet-b8', onehot=onehot, onehot2=onehot2)
model.name = "EfficientNet_B8"
print("EfficientNet B7 Loaded!")
return model
def EfficientNet_B6(pretrained=True, num_class=5, advprop=False, onehot=1, onehot2=0):
if pretrained:
model = EfficientNet.from_pretrained('efficientnet-b6', num_classes=num_class, onehot=onehot, onehot2=onehot2)
for name, param in model.named_parameters():
if 'fc' not in name :# and 'blocks.24' not in name and 'blocks.25' not in name
param.requires_grad = False
else:
model = EfficientNet.from_name('efficientnet-b6', onehot=onehot, onehot2=onehot2)
model.name = "EfficientNet_B6"
print("EfficientNet B6 Loaded!")
return model
def __init__(self, cfg = None, phase = 'train'):
"""
:param cfg: Network related settings.
:param phase: train or test.
"""
super(EfficientDet, self).__init__()
self.phase = phase
self.num_classes = 2
self.base = EfficientNet.from_pretrained('efficientnet-b3')
self.fpn_flag = True
if self.fpn_flag:
in_channels_list = [48,96,136,232]
out_channels = 128
self.ssh1 = DetectModule(out_channels)
self.ssh2 = DetectModule(out_channels)
self.ssh3 = DetectModule(out_channels)
self.ssh4 = DetectModule(out_channels)
'''
self.ssh1 = SSH(out_channels, out_channels)
self.ssh2 = SSH(out_channels, out_channels)
self.ssh3 = SSH(out_channels, out_channels)
self.ssh4 = SSH(out_channels, out_channels)
'''
self.fpn = FPN(in_channels_list, out_channels)
self.loc, self.conf, self.landm = self.multibox(self.num_classes);
def __init__(self,
num_classes,
network='efficientdet-d0',
D_bifpn=3,
W_bifpn=88,
D_class=3,
is_training=True,
threshold=0.5,
iou_threshold=0.5,
gpu=1):
super(EfficientDet, self).__init__()
self.backbone = EfficientNet.from_pretrained(MODEL_MAP[network])
self.is_training = is_training
self.neck = BIFPN(in_channels=self.backbone.get_list_features()[-5:],
out_channels=W_bifpn,
stack=D_bifpn,
num_outs=5)
self.bbox_head = RetinaHead(num_classes=num_classes,
in_channels=W_bifpn)
self.anchors = Anchors()
self.regressBoxes = BBoxTransform()
self.clipBoxes = ClipBoxes()
self.threshold = threshold
self.iou_threshold = iou_threshold
self.gpu = gpu
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
self.freeze_bn()
self.criterion = FocalLoss()
def __init__(self,
net='xception',
feature_layer='b3',
num_classes=2,
dropout_rate=0.5,
pretrained=False):
super().__init__()
self.num_classes = num_classes
if 'xception' in net:
self.net = xception(num_classes, escape=feature_layer)
elif net.split('-')[0] == 'efficientnet':
self.net = EfficientNet.from_pretrained(net,
advprop=True,
num_classes=num_classes,
escape=feature_layer)
self.feature_layer = feature_layer
with torch.no_grad():
layers = self.net(torch.zeros(1, 3, 100, 100))
num_features = layers[self.feature_layer].shape[1]
if pretrained:
a = torch.load(pretrained, map_location='cpu')
keys = {
i: a['state_dict'][i]
for i in a.keys() if i.startswith('net')
}
if not keys:
keys = a['state_dict']
load_state(self.net, keys)
self.pooling = nn.AdaptiveAvgPool2d(1)
self.texture_enhance = Texture_Enhance_v2(num_features, 1)
self.num_features = self.texture_enhance.output_features
self.fc = nn.Linear(self.num_features, self.num_classes)
self.dropout = nn.Dropout(dropout_rate)
def __init__(self,
num_classes,
network='efficientdet-d0',
D_bifpn=3,
W_bifpn=88):
super(EfficientDetBiFPN, self).__init__()
self.backbone = EfficientNet.get_network_from_name(MODEL_MAP[network])
self.neck = BIFPN(in_channels=self.backbone.get_list_features()[-5:],
out_channels=W_bifpn,
stack=D_bifpn,
num_outs=5)
self.bbox_head = RetinaHead(num_classes=num_classes,
in_channels=W_bifpn)
self.anchors = Anchors()
self.regressBoxes = BBoxTransform()
self.clipBoxes = ClipBoxes()
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
self.freeze_bn()
def __init__(self,
num_classes,
levels=3,
num_channels=128,
model_name='efficientdet-d0',
is_training=True,
threshold=0.5):
super(EfficientDet, self).__init__()
self.efficientnet = EfficientNet.from_pretrained(MODEL_MAP[model_name])
self.is_training = is_training
self.BIFPN = BIFPN(in_channels=self.efficientnet.get_list_features()[2:],
out_channels=256,
num_outs=5)
self.regressionModel = RegressionModel(256)
self.classificationModel = ClassificationModel(256, num_classes=num_classes)
self.anchors = Anchors()
self.regressBoxes = BBoxTransform()
self.clipBoxes = ClipBoxes()
self.threshold = threshold
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
prior = 0.01
self.classificationModel.output.weight.data.fill_(0)
self.classificationModel.output.bias.data.fill_(-math.log((1.0-prior)/prior))
self.regressionModel.output.weight.data.fill_(0)
self.regressionModel.output.bias.data.fill_(0)
self.freeze_bn()
def main():
exp_name = f'baseline_{now()}'
device, log, result_dir = setup(exp_name, conf)
train_df = load_csv(conf.train_csv)
if conf.npy:
train_images = np.load(conf.train_images)
else:
train_images = pd.read_parquet(conf.train_images)
test_df = load_csv(conf.test_csv)
if conf.npy:
test_images = np.load(conf.test_images)
else:
test_images = pd.read_parquet(conf.test_images)
log.info('done')
for i in range(5):
if i != conf.fold:
continue
if "resnet" in conf.arch or "resnext" in conf.arch:
model_ft = ResNet(conf,
arch_name=conf.arch,
input_size=conf.image_size)
model_ft.load_state_dict(
torch.load("result/baseline_2020_03_21_13_01_08/model_0.pkl"))
elif "densenet" in conf.arch:
model_ft = DenseNet(conf,
arch_name=conf.arch,
input_size=conf.image_size)
elif "efficientnet" in conf.arch:
model_ft = EfficientNet(conf, arch_name=conf.arch)
criterion = [
nn.CrossEntropyLoss(reduction="none"),
nn.CrossEntropyLoss(reduction="none"),
nn.CrossEntropyLoss(reduction="none")
]
criterion = [c.to(device) for c in criterion]
model_ft, val_preds = train_model(train_df,
train_images,
test_df,
test_images,
model_ft,
criterion,
log,
device,
result_dir,
fold=i,
num_epoch=conf.num_epoch)
torch.save(model_ft.state_dict(), result_dir / f'model_{i}.pkl')
np.save(result_dir / f'val_preds_{i}.npy', val_preds)
def __init__(self, model, ema_model, lr = 0.002, alpha=0.999, \
model_version = 'efficient', efficient_version = 'b0',
num_classes=7, device = 'cuda'):
self.model = model
self.ema_model = ema_model
self.alpha = alpha
self.lr = lr
self.device = device
if model_version == 'resnet':
self.tmp_model = WideResNet(num_classes=num_classes)
else:
self.tmp_model = EfficientNet(version=efficient_version,
num_classes=num_classes)
self.wd = 0.02 * self.lr
for param, ema_param in zip(self.model.parameters(), \
self.ema_model.parameters()):
ema_param.data.copy_(param.data)
def __init__(self, backbone, lr_channels=17, hr_channels=5):
super(isCNN, self).__init__()
self.model_name = backbone
self.lr_backbone = EfficientNet.from_name(backbone)
self.hr_backbone = EfficientNet.from_name(backbone)
self.lr_final = nn.Sequential(double_conv(self.n_channels, 64), nn.Conv2d(64, lr_channels, 1))
self.up_conv1 = up_conv(2*self.n_channels+lr_channels, 512)
self.double_conv1 = double_conv(self.size[0], 512)
self.up_conv2 = up_conv(512, 256)
self.double_conv2 = double_conv(self.size[1], 256)
self.up_conv3 = up_conv(256, 128)
self.double_conv3 = double_conv(self.size[2], 128)
self.up_conv4 = up_conv(128, 64)
self.double_conv4 = double_conv(self.size[3], 64)
self.up_conv_input = up_conv(64, 32)
self.double_conv_input = double_conv(self.size[4], 32)
self.hr_final = nn.Conv2d(self.size[5], hr_channels, kernel_size=1)
def create_model(args, model, efficient_version='b0', ema=False):
if model == 'resnet':
model = WideResNet(num_classes=args.num_classes)
elif model == 'efficient':
model = EfficientNet(version=efficient_version,
num_classes=args.num_classes)
model = model.to(args.device)
if ema:
for param in model.parameters():
param.detach_()
return model
def __init__(self,
num_classes=21,
levels=3,
num_channels=128,
model_name='efficientnet-b0'):
super(EfficientDet, self).__init__()
self.efficientnet = EfficientNet.from_pretrained(model_name)
self.BIFPN = BIFPN(in_channels=[40, 80, 112, 192, 320],
out_channels=256,
num_outs=5)
self.regressionModel = RegressionModel(256)
self.classificationModel = ClassificationModel(256, num_classes=num_classes)
self.anchors = Anchors()
def __init__(self, version, num_classes, implementation="EN-torch", pretrained=True):
super().__init__()
if implementation == "ours":
self.model = EfficientNet(version, num_classes)
elif implementation == "EN-torch":
if pretrained:
self.model = EN_torch.from_pretrained(f"efficientnet-{version}",
num_classes=num_classes)
else:
self.model = EN_torch.from_name(f"efficientnet-{version}",
num_classes=num_classes)
else:
raise NotImplementedError(
"The implementation must be either [ours, EN-torch]."
f"\nyour input: {implementation}")
def __init__(self,
num_class = 21,
levels = 3,
num_channels = 128,
model_name = 'efficientnet-b0'):
super(EfficientDet, self).__init__()
self.num_class = num_class
self.levels = levels
self.num_channels = num_channels
self.efficientnet = EfficientNet.from_pretrained(model_name)
print('efficientnet: ', self.efficientnet)
self.bifpn = BiFPN(num_channels = self.num_channels)
self.cfg = (coco, voc)[num_class == 21]
self.priorbox = PriorBox(self.cfg)
self.priors = Variable(self.priorbox.forward(), volatile=True)
def main(args):
# Step 1: parse args config
logging.basicConfig(
format=
'[%(asctime)s] [p%(process)s] [%(pathname)s:%(lineno)d] [%(levelname)s] %(message)s',
level=logging.INFO,
handlers=[
logging.FileHandler(args.log_file, mode='w'),
logging.StreamHandler()
])
print_args(args)
# Step 2: model, criterion, optimizer, scheduler
# model = MobileNetV3(mode='large').to(args.device)
model = EfficientNet.from_name(args.arch).to(args.device)
# auxiliarynet = AuxiliaryNet().to(args.device)
auxiliarynet = None
checkpoint = torch.load(args.model_path)
model.load_state_dict(checkpoint['model'])
# step 3: data
# argumetion
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
# mpiidataset = MPIIDatasets(args.dataroot, train=True, transforms=transform)
# train_dataset = GazeCaptureDatasets(args.dataroot, train=True, transforms=transform)
# mpii_val_dataset = MPIIDatasets(args.val_dataroot, train=False, transforms=transform)
val_dataset = GazeCaptureDatasets(args.val_dataroot,
train=True,
transforms=transform)
val_dataloader = DataLoader(val_dataset,
batch_size=args.val_batchsize,
shuffle=False,
num_workers=args.workers)
# step 4: run
val_loss, val_error = validate(args, val_dataloader, model, auxiliarynet,
1)
print("val_loss: '{}' val_error: '{}'".format(val_loss, val_error))
def __init__(self, net='xception',feature_layer='b3',attention_layer='final',num_classes=2, M=8,mid_dims=256,\
dropout_rate=0.5,drop_final_rate=0.5, pretrained=False,alpha=0.05,size=(380,380),margin=1,inner_margin=[0.01,0.02]):
super(MAT, self).__init__()
self.num_classes = num_classes
self.M = M
if 'xception' in net:
self.net = xception(num_classes)
elif net.split('-')[0] == 'efficientnet':
self.net = EfficientNet.from_pretrained(net,
advprop=True,
num_classes=num_classes)
self.feature_layer = feature_layer
self.attention_layer = attention_layer
with torch.no_grad():
layers = self.net(torch.zeros(1, 3, size[0], size[1]))
num_features = layers[self.feature_layer].shape[1]
self.mid_dims = mid_dims
if pretrained:
a = torch.load(pretrained, map_location='cpu')
keys = {
i: a['state_dict'][i]
for i in a.keys() if i.startswith('net')
}
if not keys:
keys = a['state_dict']
self.net.load_state_dict(keys, strict=False)
self.attentions = AttentionMap(layers[self.attention_layer].shape[1],
self.M)
self.atp = AttentionPooling()
self.texture_enhance = Texture_Enhance_v2(num_features, M)
self.num_features = self.texture_enhance.output_features
self.num_features_d = self.texture_enhance.output_features_d
self.projection_local = nn.Sequential(
nn.Linear(M * self.num_features, mid_dims), nn.Hardswish(),
nn.Linear(mid_dims, mid_dims))
self.project_final = nn.Linear(layers['final'].shape[1], mid_dims)
self.ensemble_classifier_fc = nn.Sequential(
nn.Linear(mid_dims * 2, mid_dims), nn.Hardswish(),
nn.Linear(mid_dims, num_classes))
self.auxiliary_loss = Auxiliary_Loss_v2(M, self.num_features_d,
num_classes, alpha, margin,
inner_margin)
self.dropout = nn.Dropout2d(dropout_rate, inplace=True)
self.dropout_final = nn.Dropout(drop_final_rate, inplace=True)
def __init__(self,
num_classes,
network='efficientdet-d0',
D_bifpn=3,
W_bifpn=88,
D_class=3,
is_training=True,
threshold=0.01,
iou_threshold=0.5):
super(EfficientDet, self).__init__()
# self.backbone = EfficientNet.from_pretrained(MODEL_MAP[network])
self.backbone = EfficientNet.get_network_from_name(MODEL_MAP[network])
# print backbone parameters
# params = list(self.backbone.named_parameters())
# for param_key, param_value in params:
# print("{}, {}".format(param_key, param_value.shape))
#
# for features in self.backbone.get_list_features():
# print(features)
self.is_training = is_training
self.neck = BIFPN(in_channels=self.backbone.get_list_features()[-5:],
out_channels=W_bifpn,
stack=D_bifpn,
num_outs=5)
self.bbox_head = RetinaHead(num_classes=num_classes,
in_channels=W_bifpn)
self.anchors = Anchors()
self.regressBoxes = BBoxTransform()
self.clipBoxes = ClipBoxes()
self.threshold = threshold
self.iou_threshold = iou_threshold
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
self.freeze_bn()
self.criterion = FocalLoss()
def __init__(self,
num_classes,
network='efficientdet-d0',
D_bifpn=3,
W_bifpn=88,
D_class=3,
is_training=True,
threshold=0.5,
iou_threshold=0.5):
super(EfficientDet, self).__init__()
# self.efficientnet = EfficientNet.from_pretrained(MODEL_MAP[network])
self.efficientnet = EfficientNet.from_name(
MODEL_MAP[network], override_params={'num_classes': num_classes})
self.is_training = is_training
self.BIFPN = BIFPN(
in_channels=self.efficientnet.get_list_features()[-5:],
out_channels=W_bifpn,
stack=D_bifpn,
num_outs=5)
self.regressionModel = RegressionModel(W_bifpn)
self.classificationModel = ClassificationModel(W_bifpn,
num_classes=num_classes)
self.anchors = Anchors()
self.regressBoxes = BBoxTransform()
self.clipBoxes = ClipBoxes()
self.threshold = threshold
self.iou_threshold = iou_threshold
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
prior = 0.01
self.classificationModel.output.weight.data.fill_(0)
self.classificationModel.output.bias.data.fill_(-math.log(
(1.0 - prior) / prior))
self.regressionModel.output.weight.data.fill_(0)
self.regressionModel.output.bias.data.fill_(0)
self.freeze_bn()
def __init__(self,
num_class=21,
levels=3,
num_channels=128,
model_name='efficientnet-b0'):
super(EfficientDet, self).__init__()
self.num_class = num_class
self.levels = levels
self.num_channels = num_channels
self.efficientnet = EfficientNet.from_pretrained(model_name)
self.cfg = (coco, voc)[num_class == 21]
self.priorbox = PriorBox(self.cfg)
self.priors = Variable(self.priorbox.forward(), volatile=True)
self.num_anchor = 9
self.class_module = list()
self.regress_module = list()
for _ in range(3, 8):
self.class_module.append(
nn.Sequential(
nn.Conv2d(in_channels=self.num_channels,
out_channels=64,
kernel_size=2,
stride=1),
nn.Conv2d(in_channels=64,
out_channels=self.num_anchor * num_class,
kernel_size=2,
stride=1)))
self.regress_module.append(
nn.Sequential(
nn.Conv2d(in_channels=self.num_channels,
out_channels=64,
kernel_size=2,
stride=1),
nn.Conv2d(in_channels=64,
out_channels=self.num_anchor * 4,
kernel_size=2,
stride=1)))
self.BIFPN = BIFPN(in_channels=[40, 80, 112, 192, 320],
out_channels=self.num_channels,
num_outs=5)
self.sigmoid = nn.Sigmoid()
class WeightEMA(object):
def __init__(self, model, ema_model, lr = 0.002, alpha=0.999, \
model_version = 'efficient', efficient_version = 'b0',
num_classes=7, device = 'cuda'):
self.model = model
self.ema_model = ema_model
self.alpha = alpha
self.lr = lr
self.device = device
if model_version == 'resnet':
self.tmp_model = WideResNet(num_classes=num_classes)
else:
self.tmp_model = EfficientNet(version=efficient_version,
num_classes=num_classes)
self.wd = 0.02 * self.lr
for param, ema_param in zip(self.model.parameters(), \
self.ema_model.parameters()):
ema_param.data.copy_(param.data)
def step(self, bn=False):
self.model.to('cpu')
self.ema_model.to('cpu')
self.tmp_model.to('cpu')
if bn:
# copy batchnorm stats to ema model
for ema_param, tmp_param in zip(self.ema_model.parameters(), \
self.tmp_model.parameters()):
tmp_param.data.copy_(ema_param.data.detach())
self.ema_model.load_state_dict(self.model.state_dict())
for ema_param, tmp_param in zip(self.ema_model.parameters(), \
self.tmp_model.parameters()):
ema_param.data.copy_(tmp_param.data.detach())
else:
one_minus_alpha = 1.0 - self.alpha
for param, ema_param in zip(self.model.parameters(), \
self.ema_model.parameters()):
ema_param.data.mul_(self.alpha)
ema_param.data.add_(param.data.detach() * one_minus_alpha)
# customized weight decay
param.data.mul_(1 - self.wd)
self.model.to(self.device)
self.ema_model.to(self.device)
self.tmp_model.to(self.device)
def __init__(self, backbone, out_channels=2, concat_input=True):
super().__init__()
self.model_name = backbone
self.backbone = EfficientNet.from_name(backbone)
self.concat_input = concat_input
self.up_conv1 = up_conv(self.n_channels, 512)
self.double_conv1 = double_conv(self.size[0], 512)
self.up_conv2 = up_conv(512, 256)
self.double_conv2 = double_conv(self.size[1], 256)
self.up_conv3 = up_conv(256, 128)
self.double_conv3 = double_conv(self.size[2], 128)
self.up_conv4 = up_conv(128, 64)
self.double_conv4 = double_conv(self.size[3], 64)
if self.concat_input:
self.up_conv_input = up_conv(64, 32)
self.double_conv_input = double_conv(self.size[4], 32)
self.final_conv = nn.Conv2d(self.size[5], out_channels, kernel_size=1)
def _infer(model: EfficientNet, img):
# preprocess image
aspect_ratio = img.size[0] / img.size[1]
img = img.resize((int(224 * max(aspect_ratio, 1.0)),
int(224 * max(1.0 / aspect_ratio, 1.0))))
img = np.array(img)
y0, x0 = (np.asarray(img.shape)[:2] - 224) // 2
img = img[y0:y0 + 224, x0:x0 + 224]
# low level preprocess
img = np.moveaxis(img, [2, 0, 1], [0, 1, 2])
img = img.astype(np.float32)[:3].reshape(1, 3, 224, 224)
img /= 255.0
img -= np.array([0.485, 0.456, 0.406]).reshape((1, -1, 1, 1))
img /= np.array([0.229, 0.224, 0.225]).reshape((1, -1, 1, 1))
# run the net
out = model.forward(Tensor(img)).cpu()
class_id = np.argmax(out.data)
return _LABELS[np.argmax(out.data)]
def __init__(self):
super(EfficientBase, self).__init__()
self.model_name = 'efficientnet-b0'
self.encoder = EfficientNet.from_name('efficientnet-b0')
self.size = [1280, 80, 40, 24, 16]
# sum
self.decoder5 = self._make_deconv_layer(DecoderBlock,
self.size[0],
self.size[1],
stride=2)
self.decoder4 = self._make_deconv_layer(DecoderBlock,
self.size[1],
self.size[2],
stride=2)
self.decoder3 = self._make_deconv_layer(DecoderBlock,
self.size[2],
self.size[3],
stride=2)
self.decoder2 = self._make_deconv_layer(DecoderBlock,
self.size[3],
self.size[4],
stride=2)
self.decoder1 = self._make_deconv_layer(DecoderBlock, self.size[4],
self.size[4])
self.final = nn.Sequential(
nn.ConvTranspose2d(16,
8,
kernel_size=3,
stride=2,
padding=1,
output_padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(8, 8, kernel_size=3, padding=1),
nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(8, 2, kernel_size=1))
import cv2
import numpy as np
import torchvision.transforms as tfs
import matplotlib.pyplot as plt
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
from models.efficientnet import EfficientNet
from models.efficientdet import EfficientDet
from models.loss import FocalLoss
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
#model = EfficientNet.from_pretrained('efficientnet-b0',False,True)
parameters = torch.load('weights/efficientnet-b0.pth')
model = EfficientNet.from_name('efficientnet-b0')
parameters = [v for _, v in parameters.items()]
model_state_dict = model.state_dict()
for i, (k, v) in enumerate(model_state_dict.items()):
model_state_dict[k] = parameters[i]
torch.save(model_state_dict, 'weights/efficientnet-b0.pth')
'''
data_dir = 'data'
imgs_path = [os.path.join(data_dir, f) for f in os.listdir(data_dir)]
imgs = [cv2.resize((cv2.imread(i)[...,::-1]/255 - mean)/std,(608,608)) for i in imgs_path]
imgs = torch.stack([torch.from_numpy(i.astype(np.float32)) for i in imgs], 0).permute(0, 3, 1, 2)
imgs = imgs[:4].cuda()
features = model.extract_features(imgs)
print(features.size())
img /= np.array([0.229, 0.224, 0.225]).reshape((1,-1,1,1))
# run the net
out = model.forward(Tensor(img)).cpu()
# if you want to look at the outputs
"""
import matplotlib.pyplot as plt
plt.plot(out.data[0])
plt.show()
"""
return out, retimg
if __name__ == "__main__":
# instantiate my net
model = EfficientNet(int(os.getenv("NUM", "0")))
model.load_from_pretrained()
# category labels
import ast
lbls = fetch("https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt")
lbls = ast.literal_eval(lbls.decode('utf-8'))
# load image and preprocess
from PIL import Image
url = sys.argv[1]
if url == 'webcam':
import cv2
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
while 1:
def test_model(args):
# create model
num_classes = 2
if args.arch == 'efficientnet_b0':
if args.pretrained:
model = EfficientNet.from_pretrained("efficientnet-b0",
quantize=args.quantize,
num_classes=num_classes)
else:
model = EfficientNet.from_name(
"efficientnet-b0",
quantize=args.quantize,
override_params={'num_classes': num_classes})
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'mobilenet_v1':
model = mobilenet_v1(quantize=args.quantize, num_classes=num_classes)
model = torch.nn.DataParallel(model).cuda()
if args.pretrained:
checkpoint = torch.load(args.resume)
state_dict = checkpoint['state_dict']
if num_classes != 1000:
new_dict = {
k: v
for k, v in state_dict.items() if 'fc' not in k
}
state_dict = new_dict
res = model.load_state_dict(state_dict, strict=False)
for missing_key in res.missing_keys:
assert 'quantize' in missing_key or 'fc' in missing_key
elif args.arch == 'mobilenet_v2':
model = mobilenet_v2(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'resnet18':
model = resnet18(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'resnet50':
model = resnet50(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'resnet152':
model = resnet152(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'resnet164':
model = resnet_164(num_classes=num_classes, quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'vgg11':
model = vgg11(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
elif args.arch == 'vgg19':
model = vgg19(pretrained=args.pretrained,
num_classes=num_classes,
quantize=args.quantize)
model = torch.nn.DataParallel(model).cuda()
else:
logging.info('No such model.')
sys.exit()
if args.resume and not args.pretrained:
if os.path.isfile(args.resume):
logging.info('=> loading checkpoint `{}`'.format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
logging.info('=> loaded checkpoint `{}` (epoch: {})'.format(
args.resume, checkpoint['epoch']))
else:
logging.info('=> no checkpoint found at `{}`'.format(args.resume))
cudnn.benchmark = False
test_loader = prepare_test_data(dataset=args.dataset,
datadir=args.datadir,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers)
criterion = nn.CrossEntropyLoss().cuda()
with torch.no_grad():
prec1 = validate(args, test_loader, model, criterion, 0)
return total_flops
if __name__ == '__main__':
if 'cifar10' in args.dataset:
num_classes = 10
input_res = 32
elif 'cifar100' in args.dataset:
num_classes = 100
input_res = 32
elif 'imagenet' in args.dataset:
num_classes = 1000
input_res = 224
if args.arch == 'efficientnet_b0':
model = EfficientNet.from_name(
"efficientnet-b0", override_params={'num_classes': num_classes})
elif args.arch == 'mobilenet_v1':
model = mobilenet_v1(num_classes=num_classes)
elif args.arch == 'mobilenet_v2':
model = mobilenet_v2(num_classes=num_classes)
elif args.arch == 'resnet18':
model = resnet18(num_classes=num_classes)
elif args.arch == 'resnet50':
model = resnet50(num_classes=num_classes)
elif args.arch == 'resnet152':
model = resnet152(num_classes=num_classes)
def __init__(self, net_type='efficientnet-b0', num_classes=2):
super(efficientnet, self).__init__()
self.net = EfficientNet.from_pretrained(net_type,
num_classes=num_classes)
def test_efficientnet(self):
model = EfficientNet(0)
X = np.zeros((BS, 3, 224, 224), dtype=np.float32)
Y = np.zeros((BS), dtype=np.int32)
train_one_step(model, X, Y)