def build_backbone_net_graph(input_tensor, architecture, weights=None): """ Build basic feature extraction networks. :param input_tensor: Input of the basic networks, should be a tensor or tf.keras.layers.Input :param architecture: The architecture name of the basic network. :param weights: Whether download and initialize weights from the pre-trained weights, could be either 'imagenet', (pre-training on ImageNet) 'noisy-student', 'None' (random initialization), or the path to the weights file to be loaded。 :return: Efficient Model and corresponding endpoints. """ assert architecture in ['efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3', 'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b7', 'efficientnet-b7', 'efficientnet-l2'] if architecture == 'efficientnet-b0': return efn.EfficientNetB0(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b1': return efn.EfficientNetB1(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b2': return efn.EfficientNetB2(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b3': return efn.EfficientNetB3(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b4': return efn.EfficientNetB4(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b5': return efn.EfficientNetB5(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b6': return efn.EfficientNetB6(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-b7': return efn.EfficientNetB7(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) elif architecture == 'efficientnet-l2': return efn.EfficientNetL2(include_top=False, weights=weights, input_tensor=input_tensor, input_shape=[None, None, 3]) else: raise ValueError("Argument architecture should in " "[efficientnet-b0, efficientnet-b1, " "efficientnet-b2, efficientnet-b3, efficientnet-b4, efficientnet-b5, " "efficientnet-b7, efficientnet-b7, efficientnet-l2] " "but get %s" % architecture)
def get_model(height=112, width=112): base_model = efficientnet.EfficientNetB1(weights='imagenet', include_top=False, input_shape=(height, width, 3)) x = base_model.output x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(1024, activation='relu')(x) x = layers.Dense(8, activation='softmax', name='predictions')(x) model = Model(inputs=base_model.input, outputs=x) return model
def effnet_retinanet(num_classes, backbone='EfficientNetB0', inputs=None, modifier=None, **kwargs): """ Constructs a retinanet model using a resnet backbone. Args num_classes: Number of classes to predict. backbone: Which backbone to use (one of ('resnet50', 'resnet101', 'resnet152')). inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)). modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example). Returns RetinaNet model with a ResNet backbone. """ # 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=(224, 224, 3)) inputs = keras.layers.Input(shape=(None, None, 3)) # get last conv layer from the end of each block [28x28, 14x14, 7x7] if backbone == 'EfficientNetB0': model = efn.EfficientNetB0(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB1': model = efn.EfficientNetB1(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB2': model = efn.EfficientNetB2(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB3': model = efn.EfficientNetB3(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB4': model = efn.EfficientNetB4(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB5': model = efn.EfficientNetB5(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB6': model = efn.EfficientNetB6(input_tensor=inputs, include_top=False, weights=None) elif backbone == 'EfficientNetB7': model = efn.EfficientNetB7(input_tensor=inputs, include_top=False, weights=None) else: raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone)) layer_outputs = ['block4a_expand_activation', 'block6a_expand_activation', 'top_activation'] layer_outputs = [ model.get_layer(name=layer_outputs[0]).output, # 28x28 model.get_layer(name=layer_outputs[1]).output, # 14x14 model.get_layer(name=layer_outputs[2]).output, # 7x7 ] # create the densenet backbone model = keras.Model(inputs=inputs, outputs=layer_outputs, name=model.name) # invoke modifier if given if modifier: model = modifier(model) # create the full model return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=model.outputs, **kwargs)
def get_efficientnet_model(model_version): if model_version == "B0": return efn.EfficientNetB0(weights='imagenet') elif model_version == "B1": return efn.EfficientNetB1(weights='imagenet') elif model_version == "B2": return efn.EfficientNetB2(weights='imagenet') elif model_version == "B3": return efn.EfficientNetB3(weights='imagenet') elif model_version == "B4": return efn.EfficientNetB4(weights='imagenet') elif model_version == "B5": return efn.EfficientNetB5(weights='imagenet') elif model_version == "B6": return efn.EfficientNetB6(weights='imagenet') elif model_version == "B7": return efn.EfficientNetB7(weights='imagenet') else: return efn.EfficientNetB0(weights='imagenet')
def efficientnetb1(self, input_shape, **kwagrs): # x_input = tf.keras.Input(shape=input_shape, name="triplet") m = efn.EfficientNetB1(input_shape=(256, 256, 3), weights=None) # remove the output layer, leave the feature extraction part m_fe = tf.keras.Model(inputs=m.inputs, outputs=m.layers[-2].output) output = tf.keras.layers.Dense(1, activation="sigmoid")(m_fe.output) m = tf.keras.Model(inputs=m_fe.inputs, outputs=output) return m
def effnet_b1(self): conv_base = efn.EfficientNetB1(weights=None, input_shape=self.input_shape, include_top=False, pooling='avg') # or weights='noisy-student' x = Flatten(name='flat')(conv_base.output) x = Dropout(0.5, name='drop1')(x) x = Dense(1024, activation='relu', name='dense1')(x) x = Dropout(0.5, name='drop2')(x) x = Dense(512, activation='relu', name='dense2')(x) x = Dense(self.nb_of_points, activation='sigmoid',name='dense3')(x) model = Model(conv_base.input, x) return model
def __init__(self, hparams): super(InputEmbedding, self).__init__() self.hparams = hparams if hparams.base_model_name == 'InceptionV3': base_model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'InceptionResNetV2': base_model = tf.keras.applications.InceptionResNetV2( include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB0': base_model = efn.EfficientNetB0(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB1': base_model = efn.EfficientNetB1(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB2': base_model = efn.EfficientNetB2(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB3': base_model = efn.EfficientNetB3(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB4': base_model = efn.EfficientNetB4(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB5': base_model = efn.EfficientNetB5(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB6': base_model = efn.EfficientNetB6(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] elif hparams.base_model_name == 'EfficientNetB7': base_model = efn.EfficientNetB7(include_top=False, weights='imagenet') base_model_layers = [layer.name for layer in base_model.layers] assert hparams.end_point in base_model_layers, "no {} layer in {}".format( hparams.end_point, hparams.base_model_name) conv_tower_output = base_model.get_layer(hparams.end_point).output self.conv_model = tf.keras.models.Model(inputs=base_model.input, outputs=conv_tower_output) self.conv_out_shape = self.conv_model.predict( np.array([np.zeros(hparams.image_shape)])).shape self.encode_cordinate = EncodeCordinate( input_shape=self.conv_out_shape)
def get_efficientnet(self): models_dict ={ 'b0': efn.EfficientNetB0(input_shape=self.shape,weights=None,include_top=False), 'b1': efn.EfficientNetB1(input_shape=self.shape,weights=None,include_top=False), 'b2': efn.EfficientNetB2(input_shape=self.shape,weights=None,include_top=False), 'b3': efn.EfficientNetB3(input_shape=self.shape,weights=None,include_top=False), 'b4': efn.EfficientNetB4(input_shape=self.shape,weights=None,include_top=False), 'b5': efn.EfficientNetB5(input_shape=self.shape,weights=None,include_top=False), 'b6': efn.EfficientNetB6(input_shape=self.shape,weights=None,include_top=False), 'b7': efn.EfficientNetB7(input_shape=self.shape,weights=None,include_top=False) } return models_dict[self.model_class]
def create_b1(include_top=False, input_shape=None, input_tensor=None, weights="noisy-student"): """ネットワークの作成。""" import efficientnet.tfkeras as efn return efn.EfficientNetB1( include_top=include_top, input_shape=input_shape, input_tensor=input_tensor, weights=weights, )
def getEffTFModel(self, n=0): modelInput = tf.keras.Input(batch_input_shape=(None, 5, self.config['net_size'], self.config['net_size'], 3)) modelInput0, modelInput1, modelInput2, modelInput3, modelInput4 = tf.split(modelInput, [1, 1, 1, 1, 1], 1) x0 = tf.squeeze(tf.keras.layers.Lambda(lambda x0: x0)(modelInput0)) x1 = tf.squeeze(tf.keras.layers.Lambda(lambda x1: x1)(modelInput1)) x2 = tf.squeeze(tf.keras.layers.Lambda(lambda x2: x2)(modelInput2)) x3 = tf.squeeze(tf.keras.layers.Lambda(lambda x3: x3)(modelInput3)) x4 = tf.squeeze(tf.keras.layers.Lambda(lambda x4: x4)(modelInput4)) net = '' if n % 10 == 0: net = efn.EfficientNetB0(include_top=False, weights='imagenet', input_shape=(self.config['net_size'], self.config['net_size'], 3), pooling='avg') elif n % 10 == 1: net = efn.EfficientNetB1(include_top=False, weights='imagenet', input_shape=(self.config['net_size'], self.config['net_size'], 3), pooling='avg') elif n % 10 == 2: net = efn.EfficientNetB2(include_top=False, weights='imagenet', input_shape=(self.config['net_size'], self.config['net_size'], 3), pooling='avg') elif n % 10 == 3: net = efn.EfficientNetB3(include_top=False, weights='imagenet', input_shape=(self.config['net_size'], self.config['net_size'], 3), pooling='avg') elif n % 10 == 4: net = efn.EfficientNetB4(include_top=False, weights='imagenet', input_shape=(self.config['net_size'], self.config['net_size'], 3), pooling='avg') activation = tf.keras.layers.LeakyReLU() self.config['rnn_size'] = 256 ret0 = net(x0) ret0 = Dense(self.config['rnn_size'], activation=activation)(ret0) ret0 = tf.expand_dims(ret0, axis=1) ret0 = self.transformer(ret0) ret1 = net(x1) ret1 = Dense(self.config['rnn_size'], activation=activation)(ret1) ret1 = tf.expand_dims(ret1, axis=1) ret1 = self.transformer(ret1) ret2 = net(x2) ret2 = Dense(self.config['rnn_size'], activation=activation)(ret2) ret2 = tf.expand_dims(ret2, axis=1) ret2 = self.transformer(ret2) ret3 = net(x3) ret3 = Dense(self.config['rnn_size'], activation=activation)(ret3) ret3 = tf.expand_dims(ret3, axis=1) ret3 = self.transformer(ret3) ret4 = net(x4) ret4 = Dense(self.config['rnn_size'], activation=activation)(ret4) ret4 = tf.expand_dims(ret4, axis=1) ret4 = self.transformer(ret4) ret = tf.concat([ret0, ret1, ret2, ret3, ret4], axis=1) print(ret) x = tf.keras.layers.Dense(self.config['rnn_size'], activation=activation)(ret) model = tf.keras.Model(modelInput, x) return model
def get_model(): with STRATEGY.scope(): efnm = efn.EfficientNetB1(weights='noisy-student', include_top=False, input_shape=(IMG_SIZE[0], IMG_SIZE[1], 3)) efnm.trainable = True model = tf.keras.models.Sequential([ efnm, tf.keras.layers.Flatten(), tf.keras.layers.Dense(CLASSES, activation='softmax') ]) model.compile(loss=LOSS_FN, optimizer=OPTIMIZER, metrics=['accuracy']) return model
def model_chooser(self, classes=2, weights=None): print("Model selection started.") name = self.model_name if(name=='C0'): self.model = efn.EfficientNetB0(include_top=True, weights=weights, classes=classes) elif(name=='C1'): self.model = efn.EfficientNetB1(include_top=True, weights=weights, classes=classes) elif(name=='C2'): self.model = efn.EfficientNetB2(include_top=True, weights=weights, classes=classes) elif(name=='C3'): self.model = efn.EfficientNetB3(include_top=True, weights=weights, classes=classes) elif(name=='C4'): self.model = efn.EfficientNetB4(include_top=True, weights=weights, classes=classes) elif(name=='C5'): self.model = efn.EfficientNetB5(include_top=True, weights=weights, classes=classes) if(classes==2): self.model.compile(optimizer="adam", loss="binary_crossentropy", metrics = ['acc']) elif(classes>2): self.model.compile(optimizer="adam", loss="categorical_crossentropy", metrics = ['acc'])
def create_base_model(base_model_name, pretrained=True, IMAGE_SIZE=[300, 300]): if pretrained is False: weights = None else: weights = "imagenet" if base_model_name == 'B0': base = efn.EfficientNetB0(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B1': base = efn.EfficientNetB1(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B2': base = efn.EfficientNetB2(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B3': base = efn.EfficientNetB3(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B4': base = efn.EfficientNetB4(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B5': base = efn.EfficientNetB5(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B6': base = efn.EfficientNetB6(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) elif base_model_name == 'B7': base = efn.EfficientNetB7(weights=weights, include_top=False, input_shape=[*IMAGE_SIZE, 3]) base = remove_dropout(base) base.trainable = True return base
def build(name, width, height, depth, n_classes, reg=0.8): """ Args: name: name of the network width: width of the images height: height of the images depth: number of channels of the images reg: regularization value """ # If Keras backend is TensorFlow inputShape = (height, width, depth) chanDim = -1 # If Keras backend is Theano if K.image_data_format() == "channels_first": inputShape = (depth, height, width) chanDim = 1 # Define the base model architecture if name == 'EfficientNetB0': base_model = efn.EfficientNetB0(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB1': base_model = efn.EfficientNetB1(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB2': base_model = efn.EfficientNetB2(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB3': base_model = efn.EfficientNetB3(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB4': base_model = efn.EfficientNetB4(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB5': base_model = efn.EfficientNetB5(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'EfficientNetB6': base_model = efn.EfficientNetB6(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'ResNet50': base_model = ResNet50(weights='imagenet', include_top=False, input_shape=inputShape) elif name == 'DenseNet121': base_model = DenseNet121(weights='imagenet', include_top=False, input_shape=inputShape) #x1 = GlobalMaxPooling2D()(base_model.output) # Compute the max pooling of the base model output #x2 = GlobalAveragePooling2D()(base_model.output) # Compute the average pooling of the base model output #x3 = Flatten()(base_model.output) # Flatten the base model output #x = Concatenate(axis=-1)([x1, x2, x3]) x = GlobalAveragePooling2D()(base_model.output) x = Dropout(0.5)(x) """ # First Dense => Relu => BN => DO fc_layer_1 = Dense(512, kernel_regularizer=l2(reg))(x) activation_1 = Activation('relu')(fc_layer_1) batch_norm_1 = BatchNormalization(axis=-1)(activation_1) dropout_1 = Dropout(0.5)(batch_norm_1) # First Dense => Relu => BN => DO fc_layer_2 = Dense(256, kernel_regularizer=l2(reg))(dropout_1) activation_2 = Activation('relu')(fc_layer_2) batch_norm_2 = BatchNormalization(axis=-1)(activation_2) dropout_2 = Dropout(0.5)(batch_norm_2) # Add the output layer output = Dense(n_classes, kernel_regularizer=l2(reg), activation='softmax')(dropout_2) """ output = Dense(n_classes, kernel_regularizer=l2(reg), activation='softmax')(x) # Create the model model = Model(inputs=base_model.inputs, outputs=output) return model
from tensorflow.python.client import device_lib print(device_lib.list_local_devices()) acc_metric = tensorflow.keras.metrics.Accuracy() bce_metric = tensorflow.keras.metrics.BinaryCrossentropy() bce_loss = tensorflow.keras.losses.BinaryCrossentropy() # Specify image size IMG_WIDTH = 240 IMG_HEIGHT = 240 CHANNELS = 3 # loading pretrained conv base model conv_base = efn.EfficientNetB1(weights="imagenet", include_top=False, input_shape=(IMG_WIDTH, IMG_HEIGHT, CHANNELS)) dropout_rate = 0.15 model = models.Sequential() model.add(conv_base) model.add(layers.GlobalAveragePooling2D(name="gap")) model.add(layers.Dropout(dropout_rate, name="dropout_out")) model.add(layers.Dense(1, activation="sigmoid")) conv_base.trainable = True print(model.summary()) print('Loading data files...') data_path = 'D:/Data/deepfake-detection-challenge/dfdc_processed' metadata = pd.read_csv(data_path + '/metadata_copy.csv')
def create_model(is_twohundred=False, is_halffeatures=True): print('Loading base model (DenseNet)..') # Encoder Layers if is_twohundred: base_model = applications.DenseNet201(input_shape=(480, 640, 3), include_top=False) else: #base_model = applications.DenseNet169(input_shape=(480, 640, 3), include_top=False) base_model = efn.EfficientNetB1(weights='imagenet',include_top=False,input_shape=((480, 640, 3))) print('Base model loaded.') # Starting point for decoder base_model_output_shape = base_model.layers[-1].output.shape # Layer freezing? for layer in base_model.layers: layer.trainable = True # Starting number of decoder filters if is_halffeatures: decode_filters = int(int(base_model_output_shape[-1]) / 2) else: decode_filters = int(base_model_output_shape[-1]) base_model.summary() # Define upsampling layer def upproject(tensor, filters, name, concat_with): up_i = BilinearUpSampling2D((2, 2), name=name + '_upsampling2d')(tensor) up_i = Concatenate(name=name + '_concat')( [up_i, base_model.get_layer(concat_with).output]) # Skip connection up_i = Conv2D(filters=filters, kernel_size=3, strides=1, padding='same', name=name + '_convA')(up_i) up_i = LeakyReLU(alpha=0.2)(up_i) up_i = Conv2D(filters=filters, kernel_size=3, strides=1, padding='same', name=name + '_convB')(up_i) up_i = LeakyReLU(alpha=0.2)(up_i) return up_i def global_non_local(X,cc): h, w , c = list(X.shape)[1], list(X.shape)[2], list(X.shape)[3] c=cc theta = Conv2D(c, kernel_size=(1,1), padding='same')(X) theta_rsh = Reshape((h*w, c))(theta) phi = Conv2D(c, kernel_size=(1,1), padding='same')(X) phi_rsh = Reshape((c, h*w))(phi) g = Conv2D(c, kernel_size=(1,1), padding='same')(X) g_rsh = Reshape((h*w, c))(g) theta_phi = tf.matmul(theta_rsh, phi_rsh) theta_phi = tf.keras.layers.Softmax()(theta_phi) theta_phi_g = tf.matmul(theta_phi, g_rsh) theta_phi_g = Reshape((h, w, c))(theta_phi_g) theta_phi_g = Conv2D(c*2, kernel_size=(1,1), padding='same')(theta_phi_g) out = Add()([theta_phi_g, X]) return out non_local=global_non_local(base_model.output,decode_filters) # Decoder Layers decoder = Conv2D(filters=decode_filters, kernel_size=1, padding='same', input_shape=base_model_output_shape, name='conv2')(non_local) decoder = upproject(decoder, int(decode_filters / 2), 'up1', concat_with='block5d_add') decoder = upproject(decoder, int(decode_filters / 4), 'up2', concat_with='block3c_add') # conv3 = Conv2D(filters=1, kernel_size=3, strides=1, padding='same', name='conv3_')(decoder) decoder = upproject(decoder, int(decode_filters / 8), 'up3', concat_with='block2c_add') # conv2 = Conv2D(filters=1, kernel_size=3, strides=1, padding='same', name='conv2_')(decoder) decoder = upproject(decoder, int(decode_filters / 16), 'up4', concat_with='block1b_add') # conv1 = Conv2D(filters=1, kernel_size=3, strides=1, padding='same', name='conv1_')(decoder) decoder = upproject(decoder, int(decode_filters / 32), 'up5', concat_with='input_1') conv0 = Conv2D(filters=1, kernel_size=3, strides=1, padding='same', name='conv0_')(decoder) ''' decoder = Conv2D(filters=decode_filters, kernel_size=1, padding='same', input_shape=base_model_output_shape, name='conv2')(base_model.output) decoder = upproject(decoder, int(decode_filters / 2), 'up1', concat_with='pool3_pool') decoder = upproject(decoder, int(decode_filters / 4), 'up2', concat_with='pool2_pool') decoder = upproject(decoder, int(decode_filters / 8), 'up3', concat_with='pool1') decoder = upproject(decoder, int(decode_filters / 16), 'up4', concat_with='conv1/relu') decoder = upproject(decoder, int(decode_filters / 32), 'up5', concat_with='input_1') conv0 = Conv2D(filters=1, kernel_size=3, strides=1, padding='same', name='conv0_')(decoder) ''' predictions_raw_0 = conv0 * 1000 # predictions_raw_1 = conv1 * 1000 # predictions_raw_2 = conv2 * 1000 # predictions_raw_3 = conv3 * 1000 predictions_0 = tf.clip_by_value(predictions_raw_0, 1.0, 65535.0) # predictions_1 = tf.clip_by_value(predictions_raw_1, 1.0, 65535.0) # predictions_2 = tf.clip_by_value(predictions_raw_2, 1.0, 65535.0) # predictions_3 = tf.clip_by_value(predictions_raw_3, 1.0, 65535.0) final_outputs_0 = tf.cast(tf.clip_by_value(predictions_raw_0, 0, 65535.0), tf.int16) eval_outputs__0 = tf.clip_by_value(predictions_raw_0, 0.1, 65535.0) # final_outputs_1 = tf.cast(tf.clip_by_value(predictions_raw_1, 0, 65535.0), tf.int16) # final_outputs_2 = tf.cast(tf.clip_by_value(predictions_raw_2, 0, 65535.0), tf.int16) # final_outputs_3 = tf.cast(tf.clip_by_value(predictions_raw_3, 0, 65535.0), tf.int16) # Create the model model = Model(inputs=base_model.input, outputs= [predictions_0, final_outputs_0, eval_outputs__0]) model.summary() #print(base_model.output) #print(base_model.layers[-1].output) print('Model created.') return model #a=create_model()
Architecture.EFFNETB4: (efn.preprocess_input, True), Architecture.EFFNETB5: (efn.preprocess_input, True), Architecture.EFFNETB6: (efn.preprocess_input, True), Architecture.EFFNETB7: (efn.preprocess_input, True), }[self] class Optimizers(enum.Enum): ADAM = 'adam' ADAMAX = 'adamax' ADADELTA = 'adadelta' ADAGRAD = 'adagrad' RMSPROP = 'rmsprop' SGD = 'sgd' NADAM = 'nadam' def __call__(self, *args, **kwargs): return { Optimizers.ADAM: tf.keras.optimizers.Adam, Optimizers.ADAMAX: tf.keras.optimizers.Adamax, Optimizers.ADADELTA: tf.keras.optimizers.Adadelta, Optimizers.ADAGRAD: tf.keras.optimizers.Adagrad, Optimizers.RMSPROP: tf.keras.optimizers.RMSprop, Optimizers.SGD: tf.keras.optimizers.SGD, Optimizers.NADAM: tf.keras.optimizers.Nadam, }[self] if __name__ == '__main__': effnet_base = efn.EfficientNetB1(weights='imagenet', include_top=False, input_shape=(256, 256, 3)) print(effnet_base.summary())
def get_model(config): # model = globals().get(config.MODEL.NAME)(1) print('model name:', config.MODEL.NAME) model_name = config.MODEL.NAME input_shape = (config.DATA.IMG_H, config.DATA.IMG_W, 3) pretrained_weight = config.MODEL.WEIGHT if pretrained_weight == 'None': pretrained_weight = None if 'EfficientNet' in model_name: ##keras.application if 'B7' in model_name: encoder = efn.EfficientNetB7(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B0' in model_name: encoder = efn.EfficientNetB0(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B1' in model_name: encoder = efn.EfficientNetB1(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B2' in model_name: encoder = efn.EfficientNetB2(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B3' in model_name: encoder = efn.EfficientNetB3(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B4' in model_name: encoder = efn.EfficientNetB4(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B5' in model_name: encoder = efn.EfficientNetB5(input_shape=input_shape, weights=pretrained_weight, include_top=False) elif 'B6' in model_name: encoder = efn.EfficientNetB6(input_shape=input_shape, weights=pretrained_weight, include_top=False) model = tf.keras.Sequential([ encoder, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dense(len(CLASSES), activation='softmax') ]) else: ##https://github.com/qubvel/classification_models #['resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'seresnet18', 'seresnet34', 'seresnet50', # 'seresnet101', 'seresnet152', 'seresnext50', 'seresnext101', 'senet154', 'resnet50v2', 'resnet101v2', # 'resnet152v2', 'resnext50', 'resnext101', 'vgg16', 'vgg19', # 'densenet121', 'densenet169', 'densenet201', # 'inceptionresnetv2', 'inceptionv3', 'xception', 'nasnetlarge', 'nasnetmobile', 'mobilenet', 'mobilenetv2'] base_model, preprocess_input = Classifiers.get(model_name) base_model = base_model(input_shape=input_shape, weights=pretrained_weight, include_top=False) x = tf.keras.layers.GlobalAveragePooling2D()(base_model.output) output = tf.keras.layers.Dense( len(CLASSES), activation=config.MODEL.OUTPUT_ACTIVATION)(x) # if 'focal' in config.LOSS.NAME: # if 'categorical_focal_loss' == config.LOSS.NAME: # else: # output = tf.keras.layers.Dense(len(CLASSES), activation='sigmoid')(x) # else: # output = tf.keras.layers.Dense(len(CLASSES), activation='softmax')(x) model = tf.keras.models.Model(inputs=[base_model.input], outputs=[output]) return model
data = next(test_ds.as_numpy_iterator()) # # @tf.custom_gradient # def softhardthresh(x): # mask = tf.nn.sigmoid(x) # def grad(dy): # return dy * (mask * (1 - mask)) # return tf.cast(mask >= 0.5, tf.float32), grad actfun = 'swish' with tf.device(args.device): model_ = efn.EfficientNetB1( weights=None, include_top=False, pooling='max', input_shape=data[0][1][0].shape) # or weights='noisy-student' feats = layers.Dense(128, activation=actfun)(model_.output) output = layers.Dense(32)(feats) model_full = tf.keras.Model(model_.input, tf.nn.tanh(output), name='model_full') x = layers.Dense(32, activation=actfun)(output) output = layers.Dense(args.CLASS_NAMES.shape[0])(x) model_weaksup_full = tf.keras.Model(model_.input, output, name='class_model_full') model_ = efn.EfficientNetB0(