def load(cls):
# 從google drive載入模型
st = datetime.datetime.now()
download_model_from_google_drive('13XZPWh8QhEsC8EdIp1niLtZz0ipatSGC',
dirname, 'word2vec_chinese.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'word2vec_chinese.pth')))
recovery_model.locale = locale.getdefaultlocale()[0].lower()
recovery_model.to(get_device())
download_file_from_google_drive(
file_id='16yDlJJ4-O9pHF-ZbXy7XPZZk6vo3aw4e',
dirname=os.path.join(_trident_dir, 'download'),
filename='vocabs_tw.txt')
if not hasattr(recovery_model,
'tw2cn') or recovery_model.tw2cn is None:
with open(download_path, 'r', encoding='utf-8-sig') as f:
vocabs_tw = f.readlines()
vocabs_tw = [
s.replace('\n', '') for s in vocabs_tw if s != '\n'
]
recovery_model.tw2cn = OrderedDict()
recovery_model.cn2tw = OrderedDict()
for i, (w, w_cn) in tqdm(
enumerate(zip(vocabs_tw,
recovery_model._vocabs.keys()))):
if w not in recovery_model.tw2cn:
recovery_model.tw2cn[w] = w_cn
recovery_model.cn2tw[w_cn] = w
et = datetime.datetime.now()
print('total loading time:{0}'.format(et - st))
return recovery_model
def VGG11(include_top=True,
pretrained=True,
freeze_features=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
vgg11 = make_vgg_layers(cfgs['A'], classes)
vgg11.input_shape = input_shape
if pretrained:
download_model_from_google_drive('1PV9-AwgD1v-JxDRzduOjjGduIR7MDhPW',
dirname, 'vgg11.pth')
recovery_model = load(os.path.join(dirname, 'vgg11.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'vgg11'
recovery_model = _make_recovery_model_include_top(
recovery_model,
input_shape=input_shape,
include_top=include_top,
classes=classes,
freeze_features=freeze_features)
vgg11.model = recovery_model
else:
vgg11.model = _make_recovery_model_include_top(vgg11.model,
include_top=include_top,
classes=classes,
freeze_features=True)
vgg11.model.input_shape = input_shape
vgg11.model.to(_device)
return vgg11
def VGG16(include_top=True,
pretrained=True,
freeze_features=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
vgg16 = make_vgg_layers(cfgs['D'], classes)
vgg16.input_shape = input_shape
if pretrained == True:
download_model_from_google_drive('1uXiH5MSy1rvxrHjW4uB9E2BHMM8b0Fwr',
dirname, 'vgg16.pth')
recovery_model = load(os.path.join(dirname, 'vgg16.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'vgg16'
recovery_model = _make_recovery_model_include_top(
recovery_model,
input_shape=input_shape,
include_top=include_top,
classes=classes,
freeze_features=freeze_features)
vgg16.model = recovery_model
else:
vgg16.model = _make_recovery_model_include_top(vgg16.model,
include_top=include_top,
classes=classes,
freeze_features=True)
vgg16.model.input_shape = input_shape
vgg16.model.to(_device)
return vgg16
def VGG13(include_top=True,
pretrained=True,
freeze_features=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
vgg13 = make_vgg_layers(cfgs['B'], classes)
if pretrained == True:
download_model_from_google_drive('1wx67gmQ8eHWXs2mhJmNl-t-cFNw7dJ7O',
dirname, 'vgg13.pth')
recovery_model = load(os.path.join(dirname, 'vgg13.pth'))
recovery_model = _make_recovery_model_include_top(
recovery_model,
input_shape=input_shape,
include_top=include_top,
classes=classes,
freeze_features=freeze_features)
vgg13.model = recovery_model
else:
vgg13.model = _make_recovery_model_include_top(vgg13.model,
include_top=include_top,
classes=classes,
freeze_features=True)
vgg13.model.input_shape = input_shape
vgg13.model.to(_device)
return vgg13
def VGG19(include_top=True,
pretrained=True,
freeze_features=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
vgg19 = make_vgg_layers(cfgs['E'], classes)
vgg19.input_shape = input_shape
if pretrained == True:
download_model_from_google_drive('1nqQJLYMzeiUX9hji39-rrBUG42YyjhYg',
dirname, 'vgg19.pth')
recovery_model = load(os.path.join(dirname, 'vgg19.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'vgg19'
recovery_model = _make_recovery_model_include_top(
recovery_model,
input_shape=input_shape,
include_top=include_top,
classes=classes,
freeze_features=freeze_features)
vgg19.model = recovery_model
else:
vgg19.model = _make_recovery_model_include_top(vgg19.model,
include_top=include_top,
classes=classes,
freeze_features=True)
vgg19.model.input_shape = input_shape
vgg19.model.to(_device)
return vgg19
def ResNet152(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape)==3:
input_shape=tuple(input_shape)
else:
input_shape=(3, 224, 224)
resnet152 =ResNet(bottleneck, [3, 8, 36, 3], input_shape,num_classes=classes,include_top=include_top, model_name='resnet152')
if pretrained==True:
download_model_from_google_drive(model_urls['resnet152'],dirname,'resnet152.pth')
recovery_model=load(os.path.join(dirname,'resnet152.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model = _make_recovery_model_include_top(recovery_model,input_shape=input_shape, include_top=include_top, classes=classes, freeze_features=freeze_features)
resnet152.model = recovery_model
else:
resnet152.model = _make_recovery_model_include_top(resnet152.model, include_top=include_top, classes=classes, freeze_features=False)
resnet152.model.input_shape = input_shape
resnet152.model.to(_device)
return resnet152
#
#
# resnet34=ResNet(basic_block, [3, 4, 6, 3], (3, 224, 224))
# resnet50=ResNet(bottleneck, [3, 4, 6, 3], (3, 224, 224))
# resnet101=ResNet(bottleneck, [3, 4, 23, 3], (3, 224, 224))
# resnet152=ResNet(bottleneck, [3, 8, 36, 3], (3, 224, 224))
def VGG16(include_top=True,
pretrained=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (224, 224, 3)
vgg16 = make_vgg_layers(cfgs['D'], classes)
vgg16.input_shape = input_shape
if pretrained == True:
download_model_from_google_drive('1fozCY4Yv_ud5UGpv7q4M9tcxZ2ryDCTb',
dirname, 'vgg16_tf.pth')
recovery_model = load(os.path.join(dirname, 'vgg16_tf.pth'))
recovery_model.name = 'vgg16'
recovery_model.eval()
with tf.device(get_device()):
if include_top == False:
[recovery_model.remove_at(-1) for i in range(7)]
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc3', Dense(classes, activation=None, name='fc3'))
recovery_model.add_module('softmax',
SoftMax(name='softmax'))
vgg16.model = recovery_model
return vgg16
def RfbNet(include_top=True,
pretrained=True,
input_shape=None,
base_filters=16,
num_classes=1,
num_regressors=4,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 480, 640)
rfbnet = SsdDetectionModel(input_shape=(3, 480, 640),
output=RFBnet(base_filters=base_filters,
num_classes=num_classes,
num_regressors=num_regressors))
rfbnet.palette[0] = (128, 255, 128)
rfbnet.palette[1] = (128, 255, 128)
rfbnet.preprocess_flow = [
resize((480, 640), True),
normalize(127.5, 127.5)
]
if pretrained == True:
download_model_from_google_drive('1T_0VYOHaxoyuG1fAxY-6g0C7pfXiujns',
dirname, 'version-RFB-640.pth')
recovery_model = torch.load(
os.path.join(dirname, 'version-RFB-640.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'rfb640'
recovery_model.eval()
recovery_model.to(_device)
rfbnet.model = recovery_model
return rfbnet
def VGG19(include_top=True,
pretrained=True,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (224, 224, 3)
vgg19 = make_vgg_layers(cfgs['E'], classes)
vgg19.input_shape = input_shape
if pretrained == True:
download_model_from_google_drive('1nXKMsYklBimtqs7ZRv0dQ-RIqNvgopVh',
dirname, 'vgg19_tf.pth')
recovery_model = load(os.path.join(dirname, 'vgg19_tf.pth'))
recovery_model.name = 'vgg19'
recovery_model.eval()
with tf.device(get_device()):
if include_top == False:
[recovery_model.remove_at(-1) for i in range(7)]
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc3', Dense(classes, activation=None, name='fc3'))
recovery_model.add_module('softmax',
SoftMax(name='softmax'))
vgg19.model = recovery_model
return vgg19
def load(cls):
# 從google drive載入模型
st = datetime.datetime.now()
set_device('cpu')
dirname = os.path.join(get_trident_dir(), 'models')
download_model_from_google_drive('13XZPWh8QhEsC8EdIp1niLtZz0ipatSGC',
dirname, 'word2vec_chinese.pth')
recovery_model = load(os.path.join(dirname, 'word2vec_chinese.pth'))
recovery_weight = recovery_model.state_dict()['weight']
shp = int_shape(recovery_weight)
v = cls(pretrained=True,
num_embeddings=shp[0],
embedding_dim=shp[-1],
_weight=recovery_weight,
name='word2vec_chinese')
v._vocabs = copy.deepcopy(recovery_model._vocabs)
v.tw2cn = copy.deepcopy(recovery_model.tw2cn)
v.cn2tw = copy.deepcopy(recovery_model.cn2tw)
del recovery_model
v.locale = ctx.locale
v.to(get_device())
et = datetime.datetime.now()
print('total loading time:{0}'.format(et - st))
return v
def VGG19(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape)==3:
input_shape=tuple(input_shape)
else:
input_shape=(3, 224, 224)
vgg19 =make_vgg_layers(cfgs['E'], classes)
vgg19.input_shape =input_shape
if pretrained==True:
download_model_from_google_drive('1nqQJLYMzeiUX9hji39-rrBUG42YyjhYg',dirname,'vgg19.pth')
recovery_model=load(os.path.join(dirname,'vgg19.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'vgg19'
recovery_model.eval()
if freeze_features:
recovery_model.trainable = False
recovery_model.fc1.trainable = True
recovery_model.fc2.trainable = True
recovery_model.fc3.trainable = True
if include_top==False:
[recovery_model.remove_at(-1) for i in range(7)]
vgg19.class_names = []
else:
if classes!=1000:
recovery_model.remove_at(-1)
recovery_model.add_module('fc3', Dense(classes, use_bias=True, activation='softmax'))
vgg19.class_names = []
recovery_model.to(_device)
vgg19.model=recovery_model
return vgg19
def VGG13(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape)==3:
input_shape=tuple(input_shape)
else:
input_shape=(3, 224, 224)
vgg13 =make_vgg_layers(cfgs['B'], classes)
if pretrained==True:
download_model_from_google_drive('1wx67gmQ8eHWXs2mhJmNl-t-cFNw7dJ7O',dirname,'vgg13.pth')
recovery_model=load(os.path.join(dirname,'vgg13.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.name = 'vgg13'
recovery_model.eval()
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc1.trainable = True
recovery_model.fc2.trainable = True
recovery_model.fc3.trainable = True
if include_top==False:
[recovery_model.remove_at(-1) for i in range(7)]
vgg13.class_names = []
else:
if classes!=1000:
recovery_model.remove_at(-1)
recovery_model.add_module('fc3', Dense(classes, use_bias=True, activation='softmax'))
vgg13.class_names = []
vgg13.model=recovery_model
return vgg13
def MobileNetV2(include_top=True,
pretrained=True,
input_shape=(224, 224, 3),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (224, 224, 3)
mob = MobileNet(input_shape=(224, 224, 3),
classes=classes,
use_bias=False,
width_mult=1.0,
round_nearest=8,
include_top=include_top,
model_name='mobilenet')
if pretrained == True:
download_model_from_google_drive('15LtLJHpvimV6cFGqAwJ4QALNEjeATrKe',
dirname, 'mobilenet_v2_tf.pth')
recovery_model = load(os.path.join(dirname, 'mobilenet_v2_tf.pth'))
recovery_model.eval()
if include_top == False:
recovery_model.remove_at(-1)
else:
if classes != 1000:
new_fc = Dense(classes, activation=None, name='fc')
new_fc.input_shape = recovery_model.fc.input_shape
recovery_model.fc = new_fc
mob.model = recovery_model
return mob
def DenseNet121(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3,224,224),
classes=1000,
**kwargs):
"""
Constructor the image classicication model with DenseNet121 as backbond
Args:
freeze_features ():
include_top ():
pretrained (bool): If True, returns a model pre-trained on ImageNet.
input_shape (tuple or list): the default input image size in CHW order (C, H, W)
classes (int): number of classes
References
Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf
Returns:
the image classicication model with DenseNet121
Examples:
>>> dense121 = DenseNet121(include_top=True,pretrained=True,input_shape=(3,224,224),classes=1000)
>>> 'n02124075' in dense121.infer_single_image(get_image_from_google_drive('1SwablQsZO8mBuB84xnr1IoOisE3pm03l'),1).key_list[0]
True
"""
if input_shape is not None and len(input_shape)==3:
input_shape=tuple(input_shape)
densenet121 =DenseNet([6, 12, 24, 16],32,64, include_top=include_top, pretrained=True,input_shape=input_shape, num_classes=classes,name='densenet121')
if pretrained==True:
download_model_from_google_drive('16N2BECErDMRTV5JqESEBWyylXbQmKAIk',dirname,'densenet121.pth')
recovery_model=load(os.path.join(dirname,'densenet121.pth'))
recovery_model=fix_layer(recovery_model)
recovery_model.name = 'densenet121'
recovery_model.eval()
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.classifier.trainable = True
if include_top==False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
densenet121.class_names = []
else:
if classes!=1000:
recovery_model.remove_at(-1)
recovery_model.add_module('classifier', Dense(classes, activation=None, name='classifier'))
densenet121.class_names = []
densenet121.model=recovery_model
densenet121.signature = get_signature(densenet121.model.forward)
return densenet121
def EfficientNetB5(include_top=True,
pretrained=True,
freeze_features=True,
input_shape=(456, 456, 3),
classes=1000,
**kwargs):
"""
Args:
freeze_features ():
include_top ():
pretrained ():
input_shape ():
classes ():
**kwargs ():
Returns:
"""
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (456, 456, 3)
effb5 = EfficientNet(1.6,
2.2,
default_size=input_shape,
dropout_rate=0.4,
model_name='efficientnet-b5',
include_top=include_top,
num_classes=classes)
with tf.device(get_device()):
if pretrained == True:
download_model_from_google_drive(
'1o_JQkIFUP1_-9AkiTs-x8q7gyDMyqiJz', dirname,
'efficientnet-b5_tf.pth')
recovery_model = load(
os.path.join(dirname, 'efficientnet-b5_tf.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model = _make_recovery_model_include_top(
recovery_model,
include_top=include_top,
classes=classes,
freeze_features=freeze_features)
effb5.model = recovery_model
else:
effb5.model = _make_recovery_model_include_top(
effb5.model,
include_top=include_top,
classes=classes,
freeze_features=True)
effb5.model.input_shape = input_shape
effb5.model.name = 'efficientnet-b5'
return effb5
def Pnet(pretrained=True, input_shape=(3, 12, 12), **kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 12, 12)
pnet = ImageDetectionModel(input_shape=(3, 12, 12), output=p_net())
pnet.preprocess_flow = [normalize(0, 255), image_backend_adaption]
if pretrained == True:
download_model_from_google_drive('1w9ahipO8D9U1dAXMc2BewuL0UqIBYWSX',
dirname, 'pnet.pth')
recovery_model = load(os.path.join(dirname, 'pnet.pth'))
recovery_model.to(_device)
pnet.model = recovery_model
return pnet
def Rnet(pretrained=True, input_shape=(3, 24, 24), **kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 24, 24)
rnet = ImageDetectionModel(input_shape=(3, 24, 24), output=r_net())
rnet.preprocess_flow = [normalize(0, 255), image_backend_adaption]
if pretrained == True:
download_model_from_google_drive('1CH7z133_KrcWMx9zXAblMCV8luiQ3wph',
dirname, 'rnet.pth')
recovery_model = load(os.path.join(dirname, 'rnet.pth'))
recovery_model.to(_device)
rnet.model = recovery_model
return rnet
def Onet(pretrained=True, input_shape=(3, 48, 48), **kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 48, 48)
onet = ImageDetectionModel(input_shape=(3, 48, 48), output=o_net())
onet.preprocess_flow = [normalize(0, 255), image_backend_adaption]
if pretrained == True:
download_model_from_google_drive('1a1dAlSzJOAfIz77Ic38JMQJYWDG_b7-_',
dirname, 'onet.pth')
recovery_model = load(os.path.join(dirname, 'onet.pth'))
recovery_model.to(_device)
onet.model = recovery_model
return onet
def EfficientNetB5(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(456, 456, 3),
classes=1000,
**kwargs):
"""
Args:
freeze_features ():
include_top ():
pretrained ():
input_shape ():
classes ():
**kwargs ():
Returns:
"""
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (456, 456, 3)
effb5 = EfficientNet(1.6,
2.2,
default_size=input_shape,
dropout_rate=0.4,
model_name='efficientnet-b5',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1o_JQkIFUP1_-9AkiTs-x8q7gyDMyqiJz',
dirname, 'efficientnet-b5_tf.pth')
recovery_model = load(os.path.join(dirname, 'efficientnet-b5_tf.pth'))
recovery_model = fix_layer(recovery_model)
recovery_model.input_shape = input_shape
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
else:
if classes != 1000:
new_fc = Dense(classes, activation=None, name='fc')
new_fc.input_shape = recovery_model.fc.input_shape
recovery_model.fc = new_fc
effb5.model = recovery_model
return effb5
def ResNet152(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
resnet152 = ResNet(bottleneck, [3, 8, 36, 3],
input_shape,
num_classes=classes,
include_top=include_top,
model_name='resnet152')
if pretrained == True:
download_model_from_google_drive(model_urls['resnet152'], dirname,
'resnet152.pth')
recovery_model = load(os.path.join(dirname, 'resnet152.pth'))
recovery_model = fix_layer(recovery_model)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
recovery_model.name = 'resnet152'
recovery_model.eval()
recovery_model.to(_device)
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
resnet152.class_names = []
else:
if classes != 1000:
resnet152.class_names = []
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
resnet152.model = recovery_model
return resnet152
#
#
# resnet34=ResNet(basic_block, [3, 4, 6, 3], (3, 224, 224))
# resnet50=ResNet(bottleneck, [3, 4, 6, 3], (3, 224, 224))
# resnet101=ResNet(bottleneck, [3, 4, 23, 3], (3, 224, 224))
# resnet152=ResNet(bottleneck, [3, 8, 36, 3], (3, 224, 224))
def YoLoV4(pretrained=True,
freeze_features=False,
input_shape=(3, 608, 608),
classes=80,
**kwargs):
detector = YoloDetectionModel(input_shape=input_shape, output=yolo4_body(classes, input_shape[-1]))
if pretrained:
download_model_from_google_drive('1CcbyinE8gQFjMjt05arSg2W0LLUwjsdt', dirname, 'pretrained_yolov4_mscoco.pth')
recovery_model = fix_layer(load(os.path.join(dirname, 'pretrained_yolov4_mscoco.pth')))
detector.model = recovery_model
detector.model .input_shape = input_shape
detector.model .to(get_device())
return detector
def EfficientNetB0(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 224, 224),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
effb0 = EfficientNet(1.0,
1.0,
input_shape,
0.2,
model_name='efficientnet-b0',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1bxnoDerzoNfiZZLft4ocD3DAgx4v6aTN',
dirname, 'efficientnet-b0.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'efficientnet-b0.pth')))
recovery_model.input_shape = input_shape
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb0.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb0.class_names = []
recovery_model.to(_device)
effb0.model = recovery_model
return effb0
def ResNet152(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (224, 224, 3)
input_shape = to_tensor(input_shape)
resnet152 = ResNet(bottleneck, [3, 8, 36, 3],
input_shape,
num_classes=classes,
include_top=include_top,
model_name='resnet152')
if pretrained == True:
download_model_from_google_drive('1TeVBB5ynW9E4_EgxIdjugLT8oaXnQH_c',
dirname, 'resnet152.pth')
recovery_model = load(os.path.join(dirname, 'resnet152.pth'))
recovery_model = fix_layer(recovery_model)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
recovery_model.eval()
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax(name='softmax'))
recovery_model.signature = None
if recovery_model.signature != recovery_model._signature:
recovery_model.signature = recovery_model._signature
resnet152.model = recovery_model
if resnet152.signature != resnet152.model.signature:
resnet152.signature = resnet152.model.signature
return resnet152
def Pnet(pretrained=True,
input_shape=(3, 12, 12),
freeze_features=True,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 224, 224)
pnet = ImageDetectionModel(input_shape=(3, 12, 12), output=p_net())
if pretrained == True:
download_model_from_google_drive('1w9ahipO8D9U1dAXMc2BewuL0UqIBYWSX',
dirname, 'pnet.pth')
recovery_model = fix_layer(load(os.path.join(dirname, 'pnet.pth')))
pnet.model = recovery_model
pnet.model.input_shape = input_shape
pnet.model.to(_device)
return pnet
def EfficientNetB1(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 240, 240),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 240, 240)
effb1 = EfficientNet(1.0,
1.1,
240,
0.2,
model_name='efficientnet-b1',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1F3BtnAjmDz4G9RS9Q0hqU_K7WWXCni1G',
dirname, 'efficientnet-b1.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'efficientnet-b1.pth')))
recovery_model.input_shape = input_shape
recovery_model.eval()
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb1.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb1.class_names = []
effb1.model = recovery_model
return effb1
def ResNet101(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=None,
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (224, 224, 3)
input_shape = to_tensor(input_shape)
resnet101 = ResNet(bottleneck, [3, 4, 23, 3],
input_shape,
num_classes=classes,
include_top=include_top,
use_bias=True,
model_name='resnet101')
if pretrained == True:
download_model_from_google_drive('13QYdFX3CvsNiegi-iUX1PUC0KKKgPNwr',
dirname, 'resnet101_tf.pth')
recovery_model = load(os.path.join(dirname, 'resnet101_tf.pth'))
recovery_model = fix_layer(recovery_model)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
recovery_model.eval()
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax(name='softmax'))
recovery_model.signature = None
if recovery_model.signature != recovery_model._signature:
recovery_model.signature = recovery_model._signature
resnet101.model = recovery_model
if resnet101.signature != resnet101.model.signature:
resnet101.signature = resnet101.model.signature
return resnet101
def EfficientNetB6(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 528, 528),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 528, 528)
effb6 = EfficientNet(1.8,
2.6,
528,
0.5,
model_name='efficientnet-b6',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1XJrKmcmMObN_nnjP2Z-YH_BQ3img58qF',
dirname, 'efficientnet-b6.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'efficientnet-b6.pth')))
recovery_model.input_shape = input_shape
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb6.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb6.class_names = []
effb6.model = recovery_model
return effb6
def EfficientNetB4(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 380, 380),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 380, 380)
effb4 = EfficientNet(1.4,
1.8,
380,
0.4,
model_name='efficientnet-b4',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1X4ZOBR_ETRHZJeffJHvCmWTTy9_aW8SP',
dirname, 'efficientnet-b4.pth')
recovery_model = fix_layer(
load(sanitize_path(os.path.join(dirname, 'efficientnet-b4.pth'))))
recovery_model.input_shape = input_shape
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb4.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb4.class_names = []
effb4.model = recovery_model
return effb4
def EfficientNetB7(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 600, 600),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 600, 600)
effb7 = EfficientNet(2.0,
3.1,
600,
0.5,
model_name='efficientnet-b7',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('1M2DfvsNPRCWSo_CeXnUCQOR46rvOrhLl',
dirname, 'efficientnet-b7.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'efficientnet-b7.pth')))
recovery_model.input_shape = input_shape
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb7.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb7.class_names = []
effb7.model = recovery_model
return effb7
def EfficientNetB5(include_top=True,
pretrained=True,
freeze_features=False,
input_shape=(3, 456, 456),
classes=1000,
**kwargs):
if input_shape is not None and len(input_shape) == 3:
input_shape = tuple(input_shape)
else:
input_shape = (3, 456, 456)
effb5 = EfficientNet(1.6,
2.2,
456,
0.4,
model_name='efficientnet-b5',
include_top=include_top,
num_classes=classes)
if pretrained == True:
download_model_from_google_drive('17iTD12G9oW3jYAui84MKtdY4gjd9vpgG',
dirname, 'efficientnet-b5.pth')
recovery_model = fix_layer(
load(os.path.join(dirname, 'efficientnet-b5.pth')))
recovery_model.input_shape = input_shape
recovery_model.to(_device)
if freeze_features:
recovery_model.trainable = False
recovery_model.fc.trainable = True
if include_top == False:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
effb5.class_names = []
else:
if classes != 1000:
recovery_model.remove_at(-1)
recovery_model.remove_at(-1)
recovery_model.add_module(
'fc', Dense(classes, activation=None, name='fc'))
recovery_model.add_module('softmax', SoftMax())
effb5.class_names = []
effb5.model = recovery_model
return effb5
