def save_model12(new_model_path, conv_model_path): model = NASNetLarge( input_shape=(img_width, img_height, 3), include_top=False, weights=None ) if pretrained: model = NASNetLarge( input_shape=(img_width, img_height, 3), include_top=False, weights='imagenet' ) model.summary() transfer_layer = model.get_layer('?') conv_model = Model(inputs=model.input, outputs=transfer_layer.output) new_model = Sequential() new_model.add(conv_model) new_model.add(GlobalAveragePooling2D()) if num_fc_layers>=1: new_model.add(Dense(num_fc_neurons, activation='relu')) if num_fc_layers>=2: new_model.add(Dropout(dropout)) new_model.add(Dense(num_fc_neurons, activation='relu')) if num_fc_layers>=3: new_model.add(Dropout(dropout)) new_model.add(Dense(num_fc_neurons, activation='relu')) new_model.add(Dense(num_classes, activation='softmax')) print(new_model.summary()) new_model.save(new_model_path) conv_model.save(conv_model_path) return
def build(config): image_width = config['image_processing']['image_width'] image_height = config['image_processing']['image_height'] image_channels = config['image_processing']['image_channels'] number_of_classes = config['dataset']['number_of_classes'] model_file = config['model'].get('model_file', None) regularization = config['hyper_parameters'].get('activity_regularizer', None) weights = config['model'].get('weights', None) print("weights:", weights) if weights == 'imagenet': base_model = NASNetLarge(input_shape=(image_width, image_height, image_channels), weights='imagenet', include_top=False) else: base_model = NASNetLarge(input_shape=(image_width, image_height, image_channels), weights=None, include_top=False) x = base_model.output x = GlobalAveragePooling2D()(x) if regularization is not None: regularization = getattr( importlib.import_module(f'keras.regularizers'), regularization['name']) regularization = regularization( **config['hyper_parameters']['activity_regularizer']['params']) predictions = Dense(activity_regularizer=regularization, units=number_of_classes, activation='softmax', name='predictions')(x) model = Model(inputs=base_model.input, outputs=predictions) if weights != 'imagenet' and weights is not None: print(weights, weights is not 'imagenet') model.load_weights(weights) return model
def nasnet_retinanet(num_classes, backbone='nasnet', inputs=None, modifier=None, **kwargs): k.clear_session() # choose default input if inputs is None: if keras.backend.image_data_format() == 'channels_first': inputs = keras.layers.Input(shape=(3, None, None)) else: inputs = keras.layers.Input(shape=(None, None, 3)) # create the resnet backbone if backbone == 'nasnet': nasnet_model = NASNetLarge(weights=None, include_top=False, input_tensor=inputs) else: raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone)) # invoke modifier if given if modifier: nasnet_model = modifier(nasnet_model) concatenated_features = [ nasnet_model.get_layer('add_4').output, nasnet_model.get_layer('activation_204').output, nasnet_model.output ] # create the full model return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=concatenated_features, **kwargs)
def nas_plus_conv(x_shape,y_shape): nas = NASNetLarge(weights=None, include_top=False) for layer in nas.layers: layer.trainable = False input_2 = Input(shape=x_shape, name='x_train') # Use the generated model output_resnet50_conv_2 = nas(input_2) x2 = Conv2D(64, (3, 3), padding='same')(output_resnet50_conv_2) x2 = BatchNormalization()(x2) x2 = Activation('relu')(x2) # x2= MaxPooling2D(pool_size=(2, 2))(x2) x2 = Dropout(0.30)(x2) x3 = Conv2D(128, (3, 3), padding='same')(x2) x3 = BatchNormalization()(x3) x3 = Activation('relu')(x3) # x3 = MaxPooling2D(pool_size=(2, 2))(x3) x3 = Dropout(0.30)(x3) x4 = Conv2D(128, (3, 3), padding='same')(x3) x4 = BatchNormalization()(x4) x4 = Activation('relu')(x4) # x4 = MaxPooling2D(pool_size=(2, 2))(x4) x4 = Dropout(0.30)(x4) x4 = Flatten(name='flatten_2')(x4) x4 = Dense(256, activation='relu', name='fc2')(x4) x4 = Dropout(0.30)(x4) x4 = Dense(y_shape, activation='softmax', name='fc3')(x4) model = Model(inputs=input_2, outputs=x4) return model
def build_nasnetlarge(n_classes): # Clear memory for new model K.clear_session() # Put the Inception V3 (cut out the classifer part) and our custom classifier on top base_model = NASNetLarge(weights='imagenet', include_top=False, input_tensor=Input(shape=(200, 200, 3))) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(4096)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Dropout(.5)(x) predictions = Dense(n_classes, init='glorot_uniform', W_regularizer=l2(.001), activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) # i.e. freeze all convolutional InceptionV3 layers for layer in base_model.layers: layer.trainable = False # opt = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, decay=1e-6) opt = SGD(lr=0.01, momentum=0.1, decay=1e-6, nesterov=True) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy', 'top_k_categorical_accuracy']) return model
def evaluation(args): path_img_val = '../datasets/ilsvrc2012/images/val/' path_val_info = '../datasets/ilsvrc2012/images/val.txt' if args.model == 'vgg16': model = VGG16(weights='imagenet') model.summary() elif args.model == 'resnet152': model = ResNet152(weights='imagenet') model.summary() elif args.model == 'resnet152v2': model = ResNet152V2(weights='imagenet') model.summary() elif args.model == 'inceptionresnetv2': model = InceptionResNetV2(weights='imagenet') model.summary() elif args.model == 'densenet201': model = DenseNet201(weights='imagenet') model.summary() elif args.model == 'nasnetlarge': model = NASNetLarge(weights='imagenet') model.summary() name, label = load_header_imagenet(load_file(path_val_info)) pred = list() for i, n in enumerate(name): x = preprocessing_imagenet(path_img_val + n, args) pred.append(np.argmax(model.predict(x), axis=1)[0]) if i % 1000 == 0: print(n) correct = len([p for p, l in zip(pred, label) if p == l]) print('Accuracy of the IMAGENET dataset using model %s: %.4f' % (args.model, correct / len(label)))
def _define_model(self): """Defines the CNN used to transform the data """ if self._model_name == "xception": model = Xception(include_top=False, pooling="max", input_shape=(self._height, self._width, self._n_channel)) elif self._model_name == "densenet": model = DenseNet201(include_top=False, pooling="max", input_shape=(self._height, self._width, self._n_channel)) elif self._model_name == "inception": model = InceptionV3(include_top=False, pooling="max", input_shape=(self._height, self._width, self._n_channel)) elif self._model_name == "nasnet": model = NASNetLarge(include_top=False, pooling="max", input_shape=(self._height, self._width, self._n_channel)) else: model = InceptionResNetV2(include_top=False, pooling="max", input_shape=(self._height, self._width, self._n_channel)) # Sometimes we only have one GPU so Keras will automatically detect # this; otherwise we have to specify this setting if self._ngpu <= 1: return model else: return multi_gpu_model(model=model, gpus=self._ngpu)
def nasnet_scratch(model_type: Text, in_shape: Union[None, Tuple[int, int, int]], out_units: int): '''NASNet Large (331x331 in default) or Mobile (224x224 in default) :param model_type: "Large" or "Mobile" :param in_shape: input shape in format (H, W, D), or None :param out_units: no. of classes ''' LARGE = 'LARGE' MOBILE = 'MOBILE' if model_type.upper() == LARGE: model = NASNetLarge(input_shape=in_shape, include_top=True, weights=None, input_tensor=None, classes=out_units) elif model_type.upper() == MOBILE: model = NASNetMobile(input_shape=in_shape, include_top=True, weights=None, input_tensor=None, classes=out_units) else: raise RuntimeError( 'invalid model type argument, "{}". "Large" and "Mobile" are supported.' .format(model_type)) return model
def finetune_nasnet_large(weights=None, input_shape=None, num_classes=None): base_weright = None fine_weight = None if weights: if weights == 'imagenet': base_weright = weights else: fine_weight = weights basenet = NASNetLarge(weights=base_weright, include_top=False, input_shape=input_shape) finetune_layer_after = "normal_concat_16" # 9% trainable = False for layer in basenet.layers: if layer.name == finetune_layer_after: trainable = True layer.trainable = trainable _input = basenet.input x = basenet.output x = layers.GlobalAveragePooling2D(name='final_gap')(x) _output = layers.Dense(num_classes, activation='softmax', kernel_initializer='he_normal', name='final_dense_mapping')(x) model = Model(inputs=_input, outputs=_output) if fine_weight: model.load_weights(fine_weight) return model
def nasnetlarge_model(lr, class_num, img_rows=299, img_cols=299, frozen_layer_index=-1, epoch=5, opt='adam'): nasnet_model = NASNetLarge(includ_top=False, input_tensor=None, input_shape=(img_rows, img_cols, 3), weights='imagenet', classes=class_num) for layer in nasnet_model.layers[:frozen_layer_index]: layer.trainable = False x = nasnet_model.outputs x = Dropout(0.7)(x) x = Flatten()(x) predictions = Dense(units=class_num, activation='softmax')(x) if epoch >= 5: if epoch % 5 == 0: lr = lr * 0.1 else: lr = lr model = Model(inputs=nasnet_model.inputs, outputs=predictions) optimizers = get_optimizer(lr, opt) model.summary() model.compile(optimizer=optimizers, loss='categorical_crossentropy', metrics=['accuracy']) return model
def Build_Model_NasNet(px_train , pSessionParameters , pTrainingParameters ): from keras.layers import Input from keras.applications.nasnet import NASNetLarge, NASNetMobile # Builds a new model ''' Input parameters: px_train: training data to be used to set the input shape of the model pModelBuildParameters: Dict of Parameters to define how the model is built. Return parameters: model ''' BatchNormFlag = pSessionParameters['BatchNorm'] NoClasses = pSessionParameters['ModelBuildParameters']['NoClasses'] Activation = pSessionParameters['ModelBuildParameters']['Activation'] IncludeTopFlag = pSessionParameters['ModelBuildParameters']['IncludeTop'] Model = pSessionParameters['ModelBuildParameters']['Model'] if IncludeTopFlag: if Model == 'NasNetLarge': print('Building Model: NASNetLarge') conv_base = NASNetLarge(input_shape=(px_train.shape[1:]), weights=None, include_top=True , classes = NoClasses, pooling='avg') elif Model == 'NasNetMobile': print('Building Model: NASNetMobile') conv_base = NASNetMobile(input_shape=(px_train.shape[1:]), weights=None, include_top=True , classes = NoClasses, pooling='avg') model = models.Sequential() model.add(conv_base) else: if Model == 'NasNetLarge': print('Building Model: NASNetLarge') conv_base = NASNetLarge(input_shape=(px_train.shape[1:]), weights=None, include_top=True , classes = NoClasses, pooling='avg') elif Model == 'NasNetMobile': print('Building Model: NASNetMobile') conv_base = NASNetMobile(input_shape=(px_train.shape[1:]), weights=None, include_top=True , classes = NoClasses, pooling='avg') model = models.Sequential() model.add(conv_base) model = Build_Model_AddLayers(model , pSessionParameters ) model.add(layers.Dense(NoClasses, activation=Activation, name='dense_class')) return model
def create_model_NASNetLarge(include_top=False): ''' Load NASNetLarge network pretrained on imagenet :param include_top: include classification layer? :return: NASNetLarge network ''' my_model = NASNetLarge(weights='imagenet', include_top=include_top) return my_model
def train(path,BATCH_SIZE,IMG_SIZE,n_classes,save_path): datagenerator = helpers.generate_data(BATCH_SIZE,IMG_SIZE,preprocess_input,path) base_model = NASNetLarge(input_shape=(IMG_SIZE, IMG_SIZE,3), include_top=False, weights='imagenet') compiled_model = helpers.transfer_learning(base_model,n_classes) helpers.fit_model(compiled_model,datagenerator,save_path)
def predict(image): model = NASNetLarge() pred = model.predict(image) decoded_predictions = decode_predictions(pred, top=10) response = 'NASNetLarge predictions: ' + str(decoded_predictions[0][0:5]) print(response) np.argmax(pred[0]) return response
def __init__(self): self.base_model = NASNetLarge(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), include_top=False, weights=None, pooling='avg') x = Dropout(0.75)(self.base_model.output) x = Dense(10, activation='softmax', name='toplayer')(x) self.model = Model(self.base_model.input, x)
def createModelNasNet(size): nas = NASNetLarge(weights='imagenet', include_top=False, pooling=None, input_shape=size) for layer in nas.layers: layer.trainable = False pool = AveragePooling2D(pool_size=(3, 3))(nas.output) return Model(inputs=nas.input, outputs=pool)
def get_model_nasnet_large(): from keras.models import Model from keras.applications.nasnet import NASNetLarge from keras.layers.core import Dense model = NASNetLarge(input_shape=(299, 299, 3), weights=None) x = model.layers[-2].output x = Dense(7178, activation='sigmoid', name='predictions')(x) model = Model(inputs=model.input, outputs=x) return model
def apply_Feature_Extractor_model(params): """ Apply a previously trained model. :param params: Hyperparameters :return: """ model = None if params['MODEL_TYPE'] == 'InceptionV3': model = InceptionV3(weights='imagenet', include_top=False) elif params['MODEL_TYPE'] == 'NASNetLarge': model = NASNetLarge(weights='imagenet', include_top=False) elif params['MODEL_TYPE'] == 'ResNet152': model = ResNet152V2(weights='imagenet', include_top=False) print(model.summary()) base_path = params['DATA_ROOT_PATH'] for s in params['EXTRACT_ON_SETS']: if params['SPLIT_OUTPUT']: path_general = params['STORE_PATH'] + '/' + params.get( 'MODEL_TYPE', 'features') + '/' + s + '/' if not os.path.isdir( path_general): # create dir if it doesn't exist os.makedirs(path_general) list_filepath = base_path + '/' + params['IMG_FILES'][s] image_list = file2list(list_filepath) eta = -1 start_time = time.time() n_images = len(image_list) for n_sample, imname in list(enumerate(image_list)): if params['MODEL_TYPE'] == 'InceptionV3': features = inceptionV3(model, imname) elif params['MODEL_TYPE'] == 'NASNetLarge': features = nasNetLarge(model, imname) elif params['MODEL_TYPE'] == 'ResNet152': features = resNet152(model, imname) # Keras puts the spatial dimensions at the start. We may want to put them at the end if params.get('SPATIAL_LAST', True): features = features.transpose(0, 3, 1, 2) filepath = path_general + imname.split( '/')[-1][:-4] + '.npy' if imname.split( '/')[-1][-4:] == '.jpg' or imname.split('/')[-1][ -4:] == '.png' else path_general + imname.split( '/')[-1] + '.npy' numpy2file(filepath, features, permission='wb', split=False) sys.stdout.write('\r') sys.stdout.write("\t Processed %d/%d - ETA: %ds " % (n_sample, n_images, int(eta))) sys.stdout.flush() eta = (n_images - n_sample) * (time.time() - start_time) / max( n_sample, 1) print("Features saved in", path_general)
def nas_2(x_shape,y_shape): nas = NASNetLarge( weights=None,include_top=False, input_shape=x_shape, pooling='max',classes=y_shape) for layer in nas.layers[:-4]: # if layer.name in ['block5_conv1', 'block4_conv1']: # layer.trainable = True # else: layer.trainable = False model = Sequential() model.add(nas) model.add(Dense(y_shape)) model.add(Activation('softmax')) return model
def get_model(model_name, input_tensor=Input(shape=(96, 96, 3)), num_class=2): ##Modified by Dooman inputs = Input(input_shape) if model_name == "Xception": base_model = Xception(include_top=False, input_shape=input_shape) elif model_name == "ResNet50": base_model = ResNet50(include_top=False, input_shape=input_shape) elif model_name == "ResNet101": base_model = ResNet101(include_top=False, input_shape=input_shape) elif model_name == "InceptionV3": base_model = InceptionV3(include_top=False, input_shape=input_shape) elif model_name == "InceptionResNetV2": base_model = InceptionResNetV2(include_top=False, input_shape=input_shape) elif model_name == "DenseNet201": base_model = DenseNet201(include_top=False, input_shape=input_shape) elif model_name == "NASNetMobile": base_model = NASNetMobile( include_top=False, input_tensor=input_tensor) ##Modified by Dooman elif model_name == "NASNetLarge": base_model = NASNetLarge(include_top=False, input_tensor=input_tensor) if model_name == "VGG16": base_model = VGG16(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False) for layer in base_model.layers: layer.trainable = False x = base_model(inputs) output1 = GlobalMaxPooling2D()(x) output2 = GlobalAveragePooling2D()(x) output3 = Flatten()(x) outputs = Concatenate(axis=-1)([output1, output2, output3]) outputs = Dropout(0.5)(outputs) outputs = BatchNormalization()(outputs) if num_class > 1: outputs = Dense(num_class, activation="softmax")(outputs) else: outputs = Dense(1, activation="sigmoid")(outputs) model = Model(inputs, outputs) model.summary() return model
def NASNet(self): base_model = NASNetLarge(include_top=False, weights="imagenet", input_shape=(self.height, self.width, self.depth)) model = Sequential() model.add(base_model) model.add(GlobalAveragePooling2D()) model.add(Dense(512, activation='relu')) model.add(Dense(self.classes, activation='softmax')) return model
def get_NASNetLarge(classes): base_model = NASNetLarge(weights='imagenet', include_top=False) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(classes, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) return model
def model_load(): #重みvをimagenetとすると、学習済みパラメータを初期値としてResNet50を読み込む。 base_model = NASNetLarge(weights='imagenet', include_top=False, input_tensor=Input(shape=(img_size, img_size, 3))) #base_model.summary() x = base_model.output #入力を平滑化 x = Flatten()(x) #過学習防止 x = Dropout(.4)(x) return (x, base_model)
def build_model_flat(input_image): input_tensor = Input(shape=(input_image)) base_model = NASNetLarge(input_shape=input_image, input_tensor=input_tensor, include_top=False, weights=None) flat = Flatten()(base_model.output) fc_1 = Dense(4096, activation='relu')(flat) output = Dense(10 * 10, activation='sigmoid')(fc_1) model = Model(inputs=input_tensor, outputs=output) model.compile(optimizer='adam', loss=losses.binary_crossentropy) return model
def modelselect(self): if self.verbose: print("Selecting model: " + self.paramdict["model"]) if self.paramdict["model"] == "xception": self.base_model = Xception(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "inception-v2": self.base_model = InceptionResNetV2(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "inception-v3": self.base_model = InceptionV3(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "resnet50": self.base_model = ResNet50(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "vgg16": self.base_model = VGG16(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "vgg19": self.base_model = VGG19(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "mobilenet": self.base_model = MobileNet(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "densenet121": self.base_model = DenseNet121(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "densenet169": self.base_model = DenseNet169(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "densenet201": self.base_model = DenseNet201(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "nasnetlarge": self.base_model = NASNetLarge(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) elif self.paramdict["model"] == "nasnetmobile": self.base_model = NASNetMobile(input_shape=(self.paramdict['imagedims'][0], self.paramdict['imagedims'][1], 3), weights='imagenet', include_top=False) else: print("Invalid model selected!") sys.exit if self.verbose: print("Model selected!")
def nasNetLarge(weights=None, include_top=False, input_shape=(224, 224, 3)): nasNet = NASNetLarge(weights=weights, include_top=include_top, input_shape=input_shape) if include_top: WRN_WEIGHTS_PATH = "https://www.flyai.com/m/v0.8|NASNet-large.h5" else: WRN_WEIGHTS_PATH = "https://www.flyai.com/m/v0.8|NASNet-large-no-top.h5" filename = WRN_WEIGHTS_PATH.split('|')[-1] fpath = get_file(filename, WRN_WEIGHTS_PATH, cache_subdir=MODEL_PATH) nasNet.load_weights(fpath) print('NASNetLarge weights loaded!') return nasNet
def Transfer_Learning(Network): shape = (IMG_SIZE, IMG_SIZE, 3) if Network == 'NASNetLarge': base_model = NASNetLarge(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'Inception_Resnet_V2': base_model = InceptionResNetV2(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'Xception': base_model = Xception(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'InceptionV3': base_model = InceptionV3(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'DenseNet201': base_model = DenseNet201(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'MobileNetV2': base_model = MobileNetV2(input_shape=shape, weights='imagenet', include_top=False) elif Network == 'NASNetMobile': base_model = NASNetMobile(input_shape=shape, weights='imagenet', include_top=False) x = base_model.output x = GlobalAveragePooling2D(name='ex_Pool')(x) x = Dense(1024, activation='relu', name='ex_Dense1', kernel_initializer='glorot_normal')(x) x = Dense(1024, activation='relu', name='ex_Dense2', kernel_initializer='glorot_normal')(x) x = Dense(512, activation='relu', name='ex_Dense3', kernel_initializer='glorot_normal')(x) output = Dense(Num_Classes, activation='softmax', name='softmax')(x) for layer in base_model.layers: layer.trainable = train_all_weights return Model(inputs=base_model.input, outputs=output)
def get_model(self): """ Prepare full Siamese Network :return: Keras model object with full Siamese Network """ feature_base_model = NASNetLarge(include_top=False, weights='imagenet', input_shape=self.input_shape, pooling='avg') l2_norm_layer = Lambda(lambda tensor: K.l2_normalize(tensor, axis=1)) model_output = l2_norm_layer(feature_base_model.output) return self._get_actual_model(feature_base_model.input, model_output)
def get_test_neural_net(type): model = None if type == 'mobilenet_small': from keras.applications.mobilenet import MobileNet model = MobileNet((128, 128, 3), depth_multiplier=1, alpha=0.25, include_top=True, weights='imagenet') elif type == 'mobilenet': from keras.applications.mobilenet import MobileNet model = MobileNet((224, 224, 3), depth_multiplier=1, alpha=1.0, include_top=True, weights='imagenet') elif type == 'mobilenet_v2': from keras.applications.mobilenetv2 import MobileNetV2 model = MobileNetV2((224, 224, 3), depth_multiplier=1, alpha=1.4, include_top=True, weights='imagenet') elif type == 'resnet50': from keras.applications.resnet50 import ResNet50 model = ResNet50(input_shape=(224, 224, 3), include_top=True, weights='imagenet') elif type == 'inception_v3': from keras.applications.inception_v3 import InceptionV3 model = InceptionV3(input_shape=(299, 299, 3), include_top=True, weights='imagenet') elif type == 'inception_resnet_v2': from keras.applications.inception_resnet_v2 import InceptionResNetV2 model = InceptionResNetV2(input_shape=(299, 299, 3), include_top=True, weights='imagenet') elif type == 'xception': from keras.applications.xception import Xception model = Xception(input_shape=(299, 299, 3), include_top=True, weights='imagenet') elif type == 'densenet121': from keras.applications.densenet import DenseNet121 model = DenseNet121(input_shape=(224, 224, 3), include_top=True, weights='imagenet') elif type == 'densenet169': from keras.applications.densenet import DenseNet169 model = DenseNet169(input_shape=(224, 224, 3), include_top=True, weights='imagenet') elif type == 'densenet201': from keras.applications.densenet import DenseNet201 model = DenseNet201(input_shape=(224, 224, 3), include_top=True, weights='imagenet') elif type == 'nasnetmobile': from keras.applications.nasnet import NASNetMobile model = NASNetMobile(input_shape=(224, 224, 3), include_top=True, weights='imagenet') elif type == 'nasnetlarge': from keras.applications.nasnet import NASNetLarge model = NASNetLarge(input_shape=(331, 331, 3), include_top=True, weights='imagenet') elif type == 'vgg16': from keras.applications.vgg16 import VGG16 model = VGG16(input_shape=(224, 224, 3), include_top=False, pooling='avg', weights='imagenet') elif type == 'vgg19': from keras.applications.vgg19 import VGG19 model = VGG19(input_shape=(224, 224, 3), include_top=False, pooling='avg', weights='imagenet') elif type == 'multi_io': model = get_custom_multi_io_model() elif type == 'multi_model_layer': model = get_custom_model_with_other_model_as_layer() return model
def build_nasnet(): inputs = Input((96, 96, 3)) base_model = NASNetLarge(include_top=False, input_shape=(96, 96, 3))#, weights=None x = base_model(inputs) out1 = GlobalMaxPooling2D()(x) out2 = GlobalAveragePooling2D()(x) out3 = Flatten()(x) out = Concatenate(axis=-1)([out1, out2, out3]) out = Dropout(0.5)(out) out = Dense(1, activation="sigmoid", name="3_")(out) model = Model(inputs, out) model.compile(optimizer=Adam(0.0001), loss=binary_crossentropy, metrics=['acc']) model.summary() return model