def build_saveuav_large(self): num_filters = 64 size = self.chip_size input = layers.Input((size, size, 3)) down1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(input) down1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(down1) down1pool = layers.MaxPool2D(padding='same')(down1) down2 = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(down1pool) down2 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(down2) down2pool = layers.MaxPool2D(padding='same')(down2) down3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(down2pool) down3 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(down3) down3pool = layers.MaxPool2D(padding='same')(down3) y_dilate_concat = self.build_bottleneck_block(num_filters, down3pool) up3_tr = layers.Conv2DTranspose(filters=num_filters * 4, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_dilate_concat) y_up3 = layers.Concatenate()([up3_tr, down3]) y_up3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(y_up3) y_up3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(y_up3) y_up3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(y_up3) up2_tr = layers.Conv2DTranspose(filters=num_filters * 2, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_up3) y_up2_tr_add = layers.Concatenate()([up2_tr, down2]) y_up2 = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(y_up2_tr_add) y_up2 = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(y_up2) y_up2_tr_add = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(y_up2) up1_tr = layers.Conv2DTranspose(filters=num_filters, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_up2_tr_add) y_up1_tr_add = layers.Concatenate()([up1_tr, down1]) y_up1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(y_up1_tr_add) y_up1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(y_up1) y_up1_tr_add = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(y_up1) final_conv = layers.Conv2D(filters=6, kernel_size=1)(y_up1_tr_add) x = layers.Activation("softmax")(final_conv) model = models.Model(input, x) return model
def train_m(): run = wandb.init() config=run.config modell = MyCNN(config.Dropout,config.Layer1,config.Layer2,config.Layer3,config.Layer4,config.Layer5,config.Batch_Normalisation,config.Augmentation) modell.train() wandb.agent(sweep_id,train_m) input_shape=(224,224,3) Layer=[16,256,32,16,128] model =models.Sequential() model.add(layers.Conv2D(Layer[0], (3, 3), input_shape=input_shape)) model.add(layers.Activation('relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(Layer[1], (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(Layer[2], (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(Layer[3], (3, 3), activation='relu'))
def generator_model(nclasses=101, gen_arch='p4_food101', latent_dim=64): """ Return a tf image generator model. Args: nclasses: int Number of categories in the image set. gen_arch: str Generator arch in format "x_y" where x in {"z2", "p4", "p4m"} and y in {"anhir", "lysto", "rotmnist", "cifar10", "food101"} latent_dim: int Dimensionality of Gaussian latents. """ # Get latent vector: latent_vec = KL.Input(shape=(latent_dim, )) label_vec = KL.Input(shape=(nclasses, )) sc, proj_dim, proj_shape, labelemb_dim = generator_dimensionality(gen_arch) label_proj = KL.Dense( # Using SN here seems to lead to collapse labelemb_dim, use_bias=False, )(label_vec) # Concatenate noise and condition feature maps to modulate the generator: cla = KL.concatenate([latent_vec, label_proj]) # Project and reshape to spatial feature maps: gen = SN(KL.Dense(proj_dim))(cla) gen = KL.Reshape(proj_shape)(gen) if gen_arch == 'p4m_anhir': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, int(512 // sc), h_input='Z2', h_output='D4', pad='same', ) for ch in [256, 128, 64, 32]: fea = ResBlockG_film( fea, cla, int(ch // sc), h_input='D4', h_output='D4', pad='same', ) fea = GBatchNorm(h='D4', momentum=0.1)(fea) fea = KL.Activation('relu')(fea) fea = SN( GConv2D(3, kernel_size=3, h_input='D4', h_output='D4', padding='same', kernel_initializer='orthogonal'))(fea) op = GroupMaxPool('D4')(fea) elif gen_arch == 'z2_anhir': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, 512, h_input='Z2', h_output='Z2', pad='same', stride=1, group_equiv=False, ) for ch in [256, 128, 64, 32]: fea = ResBlockG_film( fea, cla, ch, h_input='Z2', h_output='Z2', pad='same', group_equiv=False, ) fea = KL.BatchNormalization( momentum=0.1, center=False, scale=False, )(fea) fea = CCBN(fea, cla, 'Z2') fea = KL.Activation('relu')(fea) op = SN(KL.Conv2D( 3, kernel_size=3, padding='same', use_bias=False, ))(fea) elif gen_arch == 'p4m_lysto': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, int(512 // sc), h_input='Z2', h_output='D4', pad='same', ) for ch in [256, 128, 64, 32, 16]: fea = ResBlockG_film( fea, cla, int(ch // sc), h_input='D4', h_output='D4', pad='same', ) fea = GBatchNorm(h='D4', momentum=0.1)(fea) fea = KL.Activation('relu')(fea) fea = SN( GConv2D(3, kernel_size=3, h_input='D4', h_output='D4', padding='same', kernel_initializer='orthogonal'))(fea) op = GroupMaxPool('D4')(fea) elif gen_arch == 'z2_lysto': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, 512, h_input='Z2', h_output='Z2', pad='same', group_equiv=False, ) for ch in [256, 128, 64, 32, 16]: fea = ResBlockG_film( fea, cla, ch, h_input='Z2', h_output='Z2', pad='same', group_equiv=False, ) fea = KL.BatchNormalization(momentum=0.1)(fea) fea = KL.Activation('relu')(fea) op = SN(KL.Conv2D( 3, kernel_size=3, padding='same', use_bias=False, ))(fea) elif gen_arch == 'p4_rotmnist': # Convolutions + Upsampling: fea = SN( GConv2D(256, kernel_size=3, h_input='Z2', h_output='C4', padding='same'))(gen) fea = GShift(h='C4')(fea) fea = KL.Activation('relu')(fea) fea = KL.UpSampling2D()(fea) fea = SN( GConv2D(128, kernel_size=3, h_input='C4', h_output='C4', padding='same'))(fea) fea = GBatchNorm(h='C4', momentum=0.1, center=False, scale=False)(fea) fea = CCBN(fea, cla, 'C4') fea = KL.Activation('relu')(fea) fea = KL.UpSampling2D()(fea) fea = SN( GConv2D(64, kernel_size=3, h_input='C4', h_output='C4', padding='same'))(fea) fea = GBatchNorm(h='C4', momentum=0.1, center=False, scale=False)(fea) fea = CCBN(fea, cla, 'C4') fea = KL.Activation('relu')(fea) fea = SN( GConv2D(1, kernel_size=3, h_input='C4', h_output='C4', padding='same'))(fea) op = GroupMaxPool('C4')(fea) elif gen_arch == 'z2_rotmnist': # Convolutions + Upsampling: fea = SN( KL.Conv2D(512, kernel_size=3, padding='same', use_bias=True, kernel_initializer='orthogonal'))(gen) fea = KL.Activation('relu')(fea) fea = KL.UpSampling2D()(fea) fea = SN( KL.Conv2D(256, kernel_size=3, padding='same', use_bias=False, kernel_initializer='orthogonal'))(fea) fea = KL.BatchNormalization( momentum=0.1, center=False, scale=False, )(fea) fea = CCBN(fea, cla, 'Z2') fea = KL.Activation('relu')(fea) fea = KL.UpSampling2D()(fea) fea = SN( KL.Conv2D(128, kernel_size=3, padding='same', use_bias=False, kernel_initializer='orthogonal'))(fea) fea = KL.BatchNormalization( momentum=0.1, center=False, scale=False, )(fea) fea = CCBN(fea, cla, 'Z2') fea = KL.Activation('relu')(fea) op = SN( KL.Conv2D(1, kernel_size=3, padding='same', use_bias=False, kernel_initializer='orthogonal'))(fea) elif gen_arch == 'p4_food101': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, int(512 // sc), h_input='Z2', h_output='C4', pad='same', ) for ch in [384, 256, 192]: fea = ResBlockG_film( fea, cla, int(ch // sc), h_input='C4', h_output='C4', pad='same', ) fea = GBatchNorm(h='C4', momentum=0.1)(fea) fea = KL.Activation('relu')(fea) fea = SN( GConv2D(3, kernel_size=3, h_input='C4', h_output='C4', padding='same', kernel_initializer='orthogonal'))(fea) op = GroupMaxPool('C4')(fea) elif gen_arch == 'z2_food101': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film(gen, cla, 512, h_input='Z2', h_output='Z2', pad='same', group_equiv=False) fea = ResBlockG_film(fea, cla, 384, h_input='Z2', h_output='Z2', pad='same', group_equiv=False) fea = ResBlockG_film(fea, cla, 256, h_input='Z2', h_output='Z2', pad='same', group_equiv=False) fea = ResBlockG_film(fea, cla, 192, h_input='Z2', h_output='Z2', pad='same', group_equiv=False) fea = KL.BatchNormalization(momentum=0.1)(fea) fea = KL.Activation('relu')(fea) op = SN( KL.Conv2D(3, kernel_size=3, padding='same', kernel_initializer='orthogonal'))(fea) elif gen_arch == 'p4_cifar10': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, int(256 // sc), h_input='Z2', h_output='C4', pad='same', ) fea = ResBlockG_film( fea, cla, int(256 // sc), h_input='C4', h_output='C4', pad='same', ) fea = ResBlockG_film( fea, cla, int(256 // sc), h_input='C4', h_output='C4', pad='same', ) fea = GBatchNorm(h='C4', momentum=0.1)(fea) fea = KL.Activation('relu')(fea) fea = SN( GConv2D(3, kernel_size=3, h_input='C4', h_output='C4', padding='same', kernel_initializer='orthogonal'))(fea) op = GroupMaxPool('C4')(fea) elif gen_arch == 'z2_cifar10': # (Residual) Convolutions + Upsampling: fea = ResBlockG_film( gen, cla, 256, h_input='Z2', h_output='Z2', pad='same', group_equiv=False, ) fea = ResBlockG_film( fea, cla, 256, h_input='Z2', h_output='Z2', pad='same', stride=1, group_equiv=False, ) fea = ResBlockG_film( fea, cla, 256, h_input='Z2', h_output='Z2', pad='same', stride=1, group_equiv=False, ) fea = KL.BatchNormalization(momentum=0.1)(fea) fea = KL.Activation('relu')(fea) op = SN(KL.Conv2D( 3, kernel_size=3, padding='same', use_bias=False, ))(fea) else: raise ValueError('Generator Architecture Unrecognized') gen_img = KL.Activation('tanh')(op) # Get final synthesized image batch # Generator model: generator = Model([latent_vec, label_vec], gen_img) return generator
def discriminator(input_size=256, A_channel=3, B_channel=3, n_layers=0, name="Discriminator"): # D1: C64-C128 # D16: C64-C128 # D70: C64-C128-C256-C512 # D286: C64-C128-C256-C512-C512-C512 def encoding_block(x, filters=32, ksize=(4, 4), strides=(2, 2), padding="valid", use_act=True, use_bn=True, name="Encoding"): x = layers.Conv2D(filters, ksize, strides, padding, name=name + "_Conv")(x) if use_bn: x = layers.BatchNormalization(name=name + "_BN")(x) if use_act: x = layers.LeakyReLU(0.2, name=name + "_Act")(x) return x input_layer_A = layers.Input(shape=(input_size, input_size, A_channel), name=name + "_Input_A") input_layer_B = layers.Input(shape=(input_size, input_size, B_channel), name=name + "_Input_B") input_layer = layers.Concatenate(name=name + "_Input_Combin")( [input_layer_A, input_layer_B]) if n_layers == 0: x = encoding_block(input_layer, 64, ksize=(1, 1), strides=(1, 1), use_bn=False, name=name + "_En1") x = encoding_block(x, 128, ksize=(1, 1), strides=(1, 1), name=name + "En2") x = encoding_block(x, 1, ksize=(1, 1), strides=(1, 1), use_act=False, use_bn=False, name=name + "En3") output = layers.Avtivation("sigmoid", name=name + "_Output")(x) return models.Model(inputs=input_layer, outputs=output, name=name) else: x = encoding_block(input_layer, 64, padding="same", use_bn=False, name=name + "_En1") for i in range(1, n_layers - 1): mul_fact = min(2**i, 8) x = encoding_block(x, mul_fact * 64, padding="same", name=name + f"_En{i+1}") mul_fact = min(2**(n_layers - 1), 8) x = encoding_block(x, mul_fact * 64, ksize=(4, 4), strides=(1, 1), padding="same", name=name + f"_En{n_layers+1}") x = encoding_block(x, 1, ksize=(4, 4), strides=(1, 1), padding="same", use_act=False, use_bn=False, name=name + f"_En{n_layers+2}") x = layers.Activation("sigmoid", name=name + "_Output")(x) return models.Model(inputs=[input_layer_A, input_layer_B], outputs=x, name=name)
#%% Perpare U-Net Xception-style model from tensorflow.keras import layers from tensorflow import keras import tensorflow as tf img_size = (448, 448) #Input da rede layer_in = layers.Input(shape=img_size + (3, )) ######################################### Encoding: x = layers.Conv2D(32, kernel_size=3, padding='same', strides=(2, 2))(layer_in) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.DepthwiseConv2D(kernel_size=3, padding="same", strides=(1, 1))(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.Conv2D(64, kernel_size=1, padding='same', strides=(1, 1))(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.DepthwiseConv2D(kernel_size=3, padding="same", strides=(2, 2))(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) for filters in [128, 256]: x = layers.Conv2D(filters, kernel_size=1, padding='same',
def conv_unit(inputs, num_filters=64, kernel_size=3, activation='relu', batch_normalization=True, use3D=False): if use3D: max_pool = layers.MaxPooling3D(pool_size=3, strides=2, padding='same', data_format=None) else: max_pool = layers.MaxPooling2D(pool_size=3, strides=2, padding='same', data_format=None) x = inputs path1, path2, path3, path4 = (conv(strides=1, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(x), conv(strides=1, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(x), conv(strides=2, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(x), max_pool(x)) if batch_normalization: path1, path2, path3 = (layers.BatchNormalization()(path1), layers.BatchNormalization()(path2), layers.BatchNormalization()(path3)) if activation is not None: path1, path2, path3 = (layers.Activation(activation)(path1), layers.Activation(activation)(path2), layers.Activation(activation)(path3)) path1, path2 = (conv(strides=1, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(path1), conv(strides=2, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(path2)) if batch_normalization: path1, path2 = (layers.BatchNormalization()(path1), layers.BatchNormalization()(path2)) if activation is not None: path1, path2 = (layers.Activation(activation)(path1), layers.Activation(activation)(path2)) path1 = conv(strides=2, use3D=use3D, useBias=(not batch_normalization), num_filters=num_filters)(path1) if batch_normalization: path1 = layers.BatchNormalization()(path1) if activation is not None: path1 = layers.Activation(activation)(path1) x = layers.Concatenate()([path1, path2, path3, path4]) return x
gt_class_ids = input_gt_class_ids[0] gt_boxes = gt_boxes[0] gt_masks = input_gt_masks[0] inputs_fpn = [rois, input_train[0][1], *mrcnn_feature_maps] # class, bbox mrcnn_class_logits, mrcnn_class, mrcnn_bbox = model.fpn_clf(inputs_fpn) mrcnn_mask = model.fpn_mask(inputs_fpn) x = mutil.PyramidROIAlign([14, 14])(inputs_fpn) # Conv layers x = model.fpn_mask.mask_conv1(x) x = model.fpn_mask.bn1(x, model.fpn_mask.train_bn) x = KL.Activation('relu')(x) x = model.fpn_mask.mask_conv2(x) x = model.fpn_mask.bn2(x, model.fpn_mask.train_bn) x = KL.Activation('relu')(x) x = model.fpn_mask.mask_conv3(x) x = model.fpn_mask.bn3(x, model.fpn_mask.train_bn) x = KL.Activation('relu')(x) x = model.fpn_mask.mask_conv4(x) x = model.fpn_mask.bn4(x, model.fpn_mask.train_bn) x = KL.Activation('relu')(x) x = model.fpn_mask.deconv(x) x = model.fpn_mask.mrcnn_mask(x)
def VGG19(num_classes, input_shape=(48, 48, 3), dropout=None, block5=True, batch_norm=True): img_input = layers.Input(shape=input_shape) #Block1 x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv1')(img_input) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) #Block2 x = layers.Conv2D(128, (3, 3), padding='same', name='block2_conv1')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(128, (3, 3), padding='same', name='block2_conv2')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) #Block3 x = layers.Conv2D(256, (3, 3), padding='same', name='block3_conv1')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(256, (3, 3), padding='same', name='block3_conv2')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(256, (3, 3), padding='same', name='block3_conv3')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(256, (3, 3), padding='same', name='block3_conv4')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) #Block4 x = layers.Conv2D(512, (3, 3), padding='same', name='block4_conv1')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), padding='same', name='block4_conv2')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), padding='same', name='block4_conv4')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) #Block5 if block5: x = layers.Conv2D(512, (3, 3), padding='same', name='block5_conv1')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), padding='same', name='block5_conv2')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.Conv2D(512, (3, 3), padding='same', name='block5_conv4')(x) if batch_norm: x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x) x = layers.AveragePooling2D((1, 1), strides=(1, 1), name='block6_pool')(x) x = layers.Flatten()(x) if dropout: x = layers.Dropout(dropout)(x) x = layers.Dense(num_classes, activation='softmax', name='predictions')(x) model = models.Model(img_input, x, name='vgg19') return model
def block2(x, filters, kernel_size=3, stride=1, dilate=False, conv_shortcut=False, name=None): """A residual block. # Arguments x: input tensor. filters: integer, filters of the bottleneck layer. kernel_size: default 3, kernel size of the bottleneck layer. stride: default 1, stride of the first layer. conv_shortcut: default False, use convolution shortcut if True, otherwise identity shortcut. name: string, block label. # Returns Output tensor for the residual block. """ bn_axis = 3 preact = SyncBatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_preact_bn')(x) preact = layers.Activation('relu', name=name + '_preact_relu')(preact) if conv_shortcut is True: shortcut = layers.Conv2D(4 * filters, 1, name=name + '_0_conv')(preact) else: if not dilate: shortcut = layers.MaxPooling2D( 1, strides=stride)(x) if stride > 1 else x else: shortcut = x x = layers.Conv2D(filters, 1, strides=1, use_bias=False, name=name + '_1_conv')(preact) x = SyncBatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x) x = layers.Activation('relu', name=name + '_1_relu')(x) if dilate: x = layers.Conv2D(filters, kernel_size, dilation_rate=2, padding='SAME', use_bias=False, name=name + '_2_conv')(x) else: x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=name + '_2_pad')(x) x = layers.Conv2D(filters, kernel_size, strides=stride, use_bias=False, name=name + '_2_conv')(x) x = SyncBatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_2_bn')(x) x = layers.Activation('relu', name=name + '_2_relu')(x) x = layers.Conv2D(4 * filters, 1, name=name + '_3_conv')(x) x = layers.Add(name=name + '_out')([shortcut, x]) return x
# Instantiate teh stack of residual units for stack in range(3): for res_block in range(num_res_blocks): strides = 1 if stack > 0 and res_block == 0: # first layer but not first stack strides = 2 # downsample y = resnet_layer(x, num_filters, strides=strides) y = resnet_layer(y, num_filters, activation=None) if stack > 0 and res_block == 0: # first layer but not first stack # linear projection residual shortcut connection to match # change dims x = resnet_layer(x, num_filters, kernel_size=1, strides=strides, activation=None, batch_normalization=False) x = layers.add([x, y]) x = layers.Activation('relu')(x) num_filters *= 2 # Add classifier on top. # v1 does not use BN after last shortcut connection-ReLU x = layers.GlobalAveragePooling2D()(x) y_predict = layers.Dense(num_classes, activation='softmax', kernel_initializer='he_normal')(x) X_train, X_test = X_train_Kf[0], X_test_Kf[0] y_train, y_test = y_train_Kf[0], y_test_Kf[0] y_train = to_categorical(y_train, 7) y_test = to_categorical(y_test, 7) total_batch = np.ceil(num_samples/batch_size)
def SVBRDF(num_classes): #=============== first layer ================== inputs = keras.Input(shape=(256, 256) + (3, )) #GF = layers.LeakyReLU()(inputs) GF = layers.AveragePooling2D((inputs.shape[1], inputs.shape[1]))(inputs) GF = layers.Dense(128)(GF) GF = layers.Activation('selu')(GF) x = layers.SeparableConv2D(128, 4, 2, padding="same")(inputs) x = layers.BatchNormalization()(x) #previous_block_activation = x # Set aside residual #========== define filters for unet =================== downfilters = np.array([128, 256, 512, 512, 512, 512, 512]) Upfilters = np.flip(np.copy(downfilters)) downfilters = np.delete(downfilters, 0) prefilter = 128 #===================== upsampling ======================= for filters in downfilters: #print(x.shape) #print(filters) GFdown = layers.AveragePooling2D((x.shape[1], x.shape[1]))(x) GFup = layers.Dense(prefilter)(GF) GF = layers.Concatenate()([GF, GFdown]) GF = layers.Dense(filters)(GF) GF = layers.Activation('selu')(GF) x = layers.Add()([x, GFup]) x = layers.LeakyReLU()(x) x = layers.SeparableConv2D(filters, 4, 2, padding="same")(x) x = layers.BatchNormalization()(x) prefilter = filters #====================== downsampling ============================ for filters in Upfilters: GFdown = layers.AveragePooling2D((x.shape[1], x.shape[1]))(x) GFup = layers.Dense(prefilter)(GF) GF = layers.Concatenate()([GF, GFdown]) GF = layers.Dense(filters)(GF) GF = layers.Activation('selu')(GF) x = layers.Add()([x, GFup]) x = layers.LeakyReLU()(x) x = layers.Conv2DTranspose(filters, 4, 2, padding="same")(x) x = layers.BatchNormalization()(x) prefilter = filters #====================== last connection ===================== GFup = layers.Dense(prefilter)(x) x = layers.Add()([x, GFup]) outputs = layers.Conv2D(num_classes, 3, activation="softmax", padding="same")(x) model = keras.Model(inputs, outputs) return model
def makeModel(input_shape, learning_rate): inputs = keras.Input(shape=input_shape) # Augment the image x = data_augmentation(inputs) # Enter the network x = layers.experimental.preprocessing.Rescaling(1.0 / 255)(x) x = layers.Conv2D(32, 3, strides=2, padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.Conv2D(64, 3, padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) previous_block_activation = x # Set aside residual for size in [128, 256, 512, 728]: x = layers.Activation("relu")(x) x = layers.SeparableConv2D(size, 3, padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.SeparableConv2D(size, 3, padding="same")(x) x = layers.BatchNormalization()(x) x = layers.MaxPooling2D(3, strides=2, padding="same")(x) # Project residual residual = layers.Conv2D(size, 1, strides=2, padding="same")( previous_block_activation ) x = layers.add([x, residual]) # Add back residual previous_block_activation = x # Set aside next residual x = layers.SeparableConv2D(1024, 3, padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.GlobalAveragePooling2D()(x) activation = "softmax" units = 3 # number of classes x = layers.Dropout(0.5)(x) outputs = layers.Dense(units, activation=activation)(x) model = keras.Model(inputs, outputs) model.compile( optimizer=keras.optimizers.SGD(momentum=0.01, nesterov=True), loss="categorical_crossentropy", metrics=[ keras.metrics.categorical_accuracy ] ) callbacks = [ keras.callbacks.ModelCheckpoint("./train_checkpoints/save_at_{epoch}.h5") ] return model, callbacks
def build_model(nx: Optional[int] = None, ny: Optional[int] = None, channels: int = 1, num_classes: int = 2, layer_depth: int = 5, filters_root: int = 64, kernel_size: int = 3, pool_size: int = 2, dropout_rate: int = 0.5, padding: str = "valid", activation: Union[str, Callable] = "relu", last_bias_initializer=None, last_activation=None, prelu=True) -> Union[Model, None]: """ Constructs a U-Net model :param nx: (Optional) image size on x-axis :param ny: (Optional) image size on y-axis :param channels: number of channels of the input tensors :param num_classes: number of classes :param layer_depth: total depth of unet :param filters_root: number of filters in top unet layer :param kernel_size: size of convolutional layers :param pool_size: size of maxplool layers :param dropout_rate: rate of dropout :param padding: padding to be used in convolutions :param activation: activation to be used :return: A TF Keras model """ inputs = Input(shape=(nx, ny, channels), name="inputs") x = inputs contracting_layers = {} conv_params = dict(filters_root=filters_root, kernel_size=kernel_size, dropout_rate=dropout_rate, padding=padding, activation=activation, prelu=prelu) for layer_idx in range(0, layer_depth - 1): x = ConvBlock(layer_idx, **conv_params)(x) contracting_layers[layer_idx] = x x = layers.MaxPooling2D((pool_size, pool_size))(x) x = ConvBlock(layer_idx + 1, **conv_params)(x) for layer_idx in range(layer_idx, -1, -1): x = UpconvBlock(layer_idx, filters_root, kernel_size, pool_size, padding, activation, prelu=prelu)(x) x = CropConcatBlock()(x, contracting_layers[layer_idx]) x = ConvBlock(layer_idx, **conv_params)(x) if last_bias_initializer is not None: x = layers.Conv2D(filters=num_classes, kernel_size=(1, 1), kernel_initializer=_get_kernel_initializer( filters_root, kernel_size), strides=1, padding=padding, bias_initializer=last_bias_initializer)(x) else: x = layers.Conv2D(filters=num_classes, kernel_size=(1, 1), kernel_initializer=_get_kernel_initializer( filters_root, kernel_size), strides=1, padding=padding)(x) if last_activation is None: print( "Wrong Usage: Build model must include a last_activation parameter that can be either 'softmax' or 'sigmoid'. The model has not been built." ) return None if last_activation == "softmax": x = layers.Activation(activation)(x) outputs = layers.Activation(last_activation, name="outputs")(x) model = Model(inputs, outputs, name="unet") return model
conv1 = layers.Conv2D(16, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(features/255.0) conv2 = layers.Conv2D(32, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(conv1) conv3 = layers.Conv2D(64, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(conv2) # Do a 1x1 convolution. conv4 = layers.Conv2D(64, kernel_size=1, strides=1)(conv3) # Upsample three times. concat1 = layers.Concatenate(axis=3)([conv3, conv4]) deconv1 = layers.Conv2DTranspose(32, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(concat1) concat2 = layers.Concatenate(axis=3)([conv2, deconv1]) deconv2 = layers.Conv2DTranspose(16, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(concat2) concat3 = layers.Concatenate(axis=3)([conv1, deconv2]) deconv3 = layers.Conv2DTranspose(1, kernel_size=5, strides=2, activation=tf.nn.relu, padding='same')(concat3) # Compute the final output. concat4 = layers.Concatenate(axis=3)([features, deconv3]) logits = layers.Conv2D(1, kernel_size=5, strides=1, padding='same')(concat4) output = layers.Activation(tf.math.sigmoid)(logits) keras_model = tf.keras.Model(inputs=features, outputs=[output, logits]) learning_rate = dc.models.optimizers.ExponentialDecay(0.01, 0.9, 250) model = dc.models.KerasModel( keras_model, loss=dc.models.losses.SigmoidCrossEntropy(), output_types=['prediction', 'loss'], learning_rate=learning_rate, model_dir='models/segmentation') if not os.path.exists('./models'): os.mkdir('models') if not os.path.exists('./models/segmentation'): os.mkdir('models/segmentation') if not RETRAIN:
# ('mse' 'mae', 'mape', 'cosine') - regression # ('acc') - classification metrics = ['mse', 'mae', 'mape'] # Best config for... # ux --> hidden_layers: 2, neurons: profile_points # uy --> hidden_layers: 2, neurons: profile_points # f --> hidden_layers: 2, neurons: profile_points hidden_layers = 2 neurons = profile_points model = tf.keras.Sequential([ layers.Dense(profile_points, input_shape=(inputs,), kernel_initializer=kernel_initializer), #layers.BatchNormalization(), layers.Activation(activation=activation), layers.Dropout(rate=dropout), layers.Dense(profile_points, kernel_initializer=kernel_initializer), #layers.BatchNormalization(), layers.Activation(activation=activation), layers.Dropout(rate=dropout), layers.Dense(outputs, kernel_initializer=kernel_initializer)]) model.summary() init = tf.global_variables_initializer() saver_def = tf.train.Saver().as_saver_def() with open('graph.pb', 'wb') as f: f.write(tf.get_default_graph().as_graph_def().SerializeToString()) if download_files:
print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) # build the model model = Sequential() model.add(layers.Dense(256, input_shape=(784, ))) model.add(Antirectifier()) model.add(layers.Dropout(0.1)) model.add(layers.Dense(256)) model.add(Antirectifier()) model.add(layers.Dropout(0.1)) model.add(layers.Dense(num_classes)) model.add(layers.Activation('softmax')) # compile the model model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # train the model model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) # next, compare with an equivalent network
def resnet(input_shape, depth, num_classes, use3D=False, useBatchNorm=True): """ResNet Version 1 Model builder [a] Stacks of 2 x (3 x 3) Conv2D-BN-ReLU Last ReLU is after the shortcut connection. At the beginning of each stage, the feature map size is downsampled by a convolutional layer with strides=2, while the number of filters is doubled. Within each stage, the layers have the same number filters and the same number of filters. Features maps sizes: stage 0: 32x32, 16 stage 1: 16x16, 32 stage 2: 8x8, 64 The Number of parameters is approx the same as Table 6 of [a]: ResNet20 0.27M ResNet32 0.46M ResNet44 0.66M ResNet56 0.85M ResNet110 1.7M # Arguments input_shape (tensor): shape of input image tensor depth (int): number of core convolutional layers num_classes (int): number of classes (CIFAR10 has 10) # Returns model (Model): Keras model instance """ if (depth - 2) % 6 != 0: raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])') # Start model definition. num_filters = 16 num_res_blocks = int((depth - 2) / 6) inputs = layers.Input(shape=input_shape) x = resnet_layer(inputs=inputs, use3D=use3D) # Instantiate the stack of residual units for stack in range(3): for res_block in range(num_res_blocks): strides = 1 if stack > 0 and res_block == 0: # first layer but not first stack strides = 2 # downsample y = resnet_layer(inputs=x, num_filters=num_filters, strides=strides, batch_normalization=useBatchNorm, use3D=use3D) y = resnet_layer(inputs=y, num_filters=num_filters, activation=None, batch_normalization=useBatchNorm, use3D=use3D) if stack > 0 and res_block == 0: # first layer but not first stack # linear projection residual shortcut connection to match # changed dims x = resnet_layer(inputs=x, num_filters=num_filters, kernel_size=1, strides=strides, activation=None, batch_normalization=False, use3D=use3D) x = layers.add([x, y]) x = layers.Activation('relu')(x) num_filters *= 2 # Add classifier on top. # v1 does not use BN after last shortcut connection-ReLU if use3D: x = layers.AveragePooling3D(pool_size=8)(x) else: x = layers.AveragePooling2D(pool_size=8)(x) y = layers.Flatten()(x) outputs = layers.Dense(num_classes, activation='softmax', kernel_initializer='he_normal')(y) # Instantiate model. model = keras.Model(inputs=inputs, outputs=outputs) return model
def build_generator(): input = tf.keras.Input(shape=(L_node, W_node, Time_steps)) # (None, 256, 256, 5) l1 = input # (None, 256, 256, 5) l2_1 = layers.Conv2D(64, 1, 1, 'same', activation='relu')(l1) # (None, 256, 256, 64) l2_1 = layers.BatchNormalization()(l2_1) l2_2 = layers.Conv2D(48, 1, 1, 'same', activation='relu')(l1) # (None, 256, 256, 48) l2_2 = layers.BatchNormalization()(l2_2) l2_2 = layers.Conv2D(64, 3, 1, 'same', activation='relu')(l2_2) # (None, 256, 256, 64) l2_2 = layers.BatchNormalization()(l2_2) l2_3 = layers.Conv2D(48, 1, 1, 'same', activation='relu')(l1) # (None, 256, 256, 48) l2_3 = layers.BatchNormalization()(l2_3) l2_3 = layers.Conv2D(64, 5, 1, 'same', activation='relu')(l2_3) # (None, 256, 256, 64) l2_3 = layers.BatchNormalization()(l2_3) l2_4 = layers.AvgPool2D(3, 1, 'same')(l1) l2_4 = layers.Conv2D(64, 1, 1, 'same', activation='relu')(l2_4) # (None, 256, 256, 64) l2_4 = layers.BatchNormalization()(l2_4) l2 = layers.concatenate([l2_1, l2_2, l2_3, l2_4], 3) # (None, 256, 256, 256) l3 = layers.Conv2D(64, 3, 1, 'same', activation='relu')(l2) # (None, 256, 256, 64) l4_1 = layers.Conv2D(128, 3, 2, 'same')(l3) # (None, 128, 128, 128) l4_1 = layers.BatchNormalization()(l4_1) l4_1 = layers.LeakyReLU(0.2)(l4_1) l5_1 = layers.Conv2D(256, 3, 2, 'same')(l4_1) # (None, 64, 64, 256) l5_1 = layers.BatchNormalization()(l5_1) l5_1 = layers.LeakyReLU(0.2)(l5_1) l6_1 = layers.Conv2D(512, 3, 2, 'same')(l5_1) # (None, 32, 32, 512) l6_1 = layers.BatchNormalization()(l6_1) l6_1 = layers.LeakyReLU(0.2)(l6_1) l7_1 = layers.Conv2D(512, 3, 2, 'same')(l6_1) # (None, 16, 16, 512) l7_1 = layers.BatchNormalization()(l7_1) l7_1 = layers.LeakyReLU(0.2)(l7_1) l8_1 = layers.Conv2DTranspose(512, 3, 2, 'same')(l7_1) # (None, 32, 32, 512) l8_1 = layers.BatchNormalization()(l8_1) l8_1 = layers.Dropout(0.3)(l8_1) l8_1 = layers.Activation('relu')(l8_1) l9_1 = layers.Conv2DTranspose(256, 3, 2, 'same')(l8_1) # (None, 64, 64, 256) l9_1 = layers.BatchNormalization()(l9_1) l9_1 = layers.Dropout(0.3)(l9_1) l9_1 = layers.Activation('relu')(l9_1) l10_1 = layers.Conv2DTranspose(128, 3, 2, 'same')(l9_1) # (None, 128, 128, 128) l10_1 = layers.BatchNormalization()(l10_1) l10_1 = layers.Dropout(0.3)(l10_1) l10_1 = layers.Activation('relu')(l10_1) l11_1 = layers.Conv2DTranspose(64, 3, 2, 'same')(l10_1) # (None, 256, 256, 64) l11_1 = layers.BatchNormalization()(l11_1) l11_1 = layers.Dropout(0.3)(l11_1) l11_1 = layers.Activation('tanh')(l11_1) l4_2 = layers.Conv2D(32, 3, 2, 'same')(l3) # (None, 128, 128, 32) l5_2 = layers.Conv2D(5, 3, 2, 'same')(l4_2) # (None, 64, 64, 5) # l5_2_1 = tf.reshape(l5_2(-1, -1, -1, 0), shape=(1, L_node, W_node, Channel)) # l5_2_2 = tf.reshape(l5_2(-1, -1, -1, 1), shape=(1, L_node, W_node, Channel)) # l5_2_3 = tf.reshape(l5_2(-1, -1, -1, 2), shape=(1, L_node, W_node, Channel)) # l5_2_4 = tf.reshape(l5_2(-1, -1, -1, 3), shape=(1, L_node, W_node, Channel)) # l5_2_5 = tf.reshape(l5_2(-1, -1, -1, 4), shape=(1, L_node, W_node, Channel)) l5_2 = tf.reshape(l5_2, shape=(-1, 5, 64, 64, 1)) # (None, 5, 64, 64, 1) l6_2 = layers.ConvLSTM2D(10, 3, 1, 'same', return_sequences=True)(l5_2) # (None, 5, 64, 64, 10) l7_2 = layers.ConvLSTM2D(20, 3, 1, 'same', return_sequences=True)(l6_2) # (None, 5, 64, 64, 20) l8_2 = layers.ConvLSTM2D(20, 3, 1, 'same', return_sequences=True)(l7_2) # (None, 5, 64, 64, 20) l9_2 = layers.ConvLSTM2D(10, 3, 1, 'same', return_sequences=False)(l8_2) # (None, 64, 64, 10) l10_2 = layers.Conv2DTranspose(32, 3, 2, 'same')(l9_2) # (None, 128, 128, 32) l10_2 = layers.BatchNormalization()(l10_2) l10_2 = layers.Dropout(0.3)(l10_2) l10_2 = layers.Activation('relu')(l10_2) l11_2 = layers.Conv2DTranspose(64, 3, 2, 'same')(l10_2) # (None, 256, 256, 64) l11_2 = layers.BatchNormalization()(l11_2) l11_2 = layers.Dropout(0.3)(l11_2) l11_2 = layers.Activation('relu')(l11_2) l12 = layers.add([l11_1, l11_2]) # (None, 256, 256, 64) l13 = layers.Conv2D(1, 3, 1, 'same', activation='tanh')(l12) # (None, 256, 256, 1) Model = tf.keras.Model(input, l13, name='generator') return Model
plt.title('Training and validation loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() plt.show() plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc, 'b', label='Validation acc') plt.title('Training and validation accuracy') plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.legend(loc='lower right') plt.show() export_model = tf.keras.Sequential([ vectorize_layer, model, layers.Activation('sigmoid') ]) export_model.compile( loss=losses.BinaryCrossentropy(from_logits=False), optimizer="adam", metrics=['accuracy'] ) # Test it with `raw_test_ds`, which yields raw strings loss, accuracy = export_model.evaluate(raw_test_ds) print(accuracy)
def _make_block_basic(self, input_tensor, first_block=True, filters=64, stride=2, radix=1, avd=False, avd_first=False, is_first=False): '''Conv2d_BN_Relu->Bn_Relu_Conv2d ''' x = input_tensor x = layers.BatchNormalization(axis=self.channel_axis, epsilon=1.001e-5)(x) x = layers.Activation(self.active)(x) short_cut = x inplanes = input_tensor.shape[-1] if stride != 1 or inplanes != filters * self.block_expansion: if self.avg_down: if self.dilation == 1: short_cut = layers.AveragePooling2D( pool_size=stride, strides=stride, padding='same', data_format='channels_last')(short_cut) else: short_cut = layers.AveragePooling2D( pool_size=1, strides=1, padding='same', data_format='channels_last')(short_cut) short_cut = layers.Conv2D( filters, kernel_size=1, strides=1, padding='same', kernel_initializer='he_normal', use_bias=False, data_format='channels_last')(short_cut) else: short_cut = layers.Conv2D( filters, kernel_size=1, strides=stride, padding='same', kernel_initializer='he_normal', use_bias=False, data_format='channels_last')(short_cut) group_width = int(filters * (self.bottleneck_width / 64.)) * self.cardinality avd = avd and (stride > 1 or is_first) avd_first = avd_first if avd: avd_layer = layers.AveragePooling2D(pool_size=3, strides=stride, padding='same', data_format='channels_last') stride = 1 if avd and avd_first: x = avd_layer(x) if radix >= 1: x = self._SplAtConv2d(x, filters=group_width, kernel_size=3, stride=stride, dilation=self.dilation, groups=self.cardinality, radix=radix) else: x = layers.Conv2D(filters, kernel_size=3, strides=stride, padding='same', kernel_initializer='he_normal', dilation_rate=self.dilation, use_bias=False, data_format='channels_last')(x) if avd and not avd_first: x = avd_layer(x) # print('can') x = layers.BatchNormalization(axis=self.channel_axis, epsilon=1.001e-5)(x) x = layers.Activation(self.active)(x) x = layers.Conv2D(filters, kernel_size=3, strides=1, padding='same', kernel_initializer='he_normal', dilation_rate=self.dilation, use_bias=False, data_format='channels_last')(x) m2 = layers.Add()([x, short_cut]) return m2
# plt.show() # plt.plot(epochs, acc, 'bo', label='Training acc') # plt.plot(epochs, val_acc, 'b', label='Validation acc') # plt.title('Training and validation accuracy') # plt.xlabel('Epochs') # plt.ylabel('Accuracy') # plt.legend(loc='lower right') # plt.show() # creating a new model for brute text print("Building and compiling export_model..") export_model = tf.keras.Sequential( [vectorize_layer, model, layers.Activation("sigmoid")]) export_model.compile( loss=losses.BinaryCrossentropy(from_logits=False), optimizer="adam", metrics=["accuracy"], ) print("Compilation ended.") # Test it with `raw_test_ds`, which yields raw strings loss, accuracy = export_model.evaluate(raw_test_ds) print("Accuracy:", accuracy) examples = [ "This movie was great!", "The movie is great!", "The movie was terrible!" ]
def build(self): input_sig = Input(shape=self.input_shape) x = self._make_stem(input_sig, stem_width=self.stem_width, deep_stem=self.deep_stem) if self.preact is False: x = layers.BatchNormalization(axis=self.channel_axis, epsilon=1.001e-5)(x) x = layers.Activation(self.active)(x) if self.verbose: print('stem_out', x.shape) x = MaxPool2D(pool_size=3, strides=2, padding='same', data_format='channels_last')(x) if self.verbose: print('MaxPool2D out', x.shape) if self.preact is True: x = layers.BatchNormalization(axis=self.channel_axis, epsilon=1.001e-5)(x) x = layers.Activation(self.active)(x) x = self._make_layer(x, blocks=self.blocks_set[0], filters=64, stride=1, is_first=False) if self.verbose: print('-' * 5, 'layer1 out', x.shape, '-' * 5) x = self._make_layer(x, blocks=self.blocks_set[1], filters=128, stride=2) if self.verbose: print('-' * 5, 'layer2 out', x.shape, '-' * 5) x = self._make_layer(x, blocks=self.blocks_set[2], filters=256, stride=2) if self.verbose: print('-' * 5, 'layer3 out', x.shape, '-' * 5) x = self._make_layer(x, blocks=self.blocks_set[3], filters=512, stride=2) if self.verbose: print('-' * 5, 'layer4 out', x.shape, '-' * 5) concats = GlobalAveragePooling2D(name='avg_pool')(x) if self.verbose: print("pool_out:", concats.shape) if self.dropout_rate > 0: x = Dropout(self.dropout_rate, noise_shape=None)(x) fc_out = Dense(self.n_classes, kernel_initializer='he_normal', use_bias=False, name='fc_NObias')(concats) if self.verbose: print("fc_out:", fc_out.shape) if self.fc_activation: fc_out = Activation(self.fc_activation)(fc_out) model = models.Model(inputs=input_sig, outputs=fc_out) if self.verbose: print("Resnest builded with input {}, output{}".format( input_sig.shape, fc_out.shape)) if self.verbose: print('-------------------------------------------') if self.verbose: print('') return model
train_X = train_X /255.0 test_X = test_X / 255.0 plt.imshow(train_X[0]) plt.colorbar() plt.show() print(train_X.shape) print(test_X.shape) train_X = train_X.reshape(-1,28,28,1) test_X = test_X.reshape(-1,28,28,1) input = layers.Input(shape=(28,28,1)) t = layers.Conv2D(filters=16,kernel_size=(5,5),strides=1)(input) t = layers.BatchNormalization(axis=1)(t) t = layers.Activation('relu')(t) t = layers.MaxPooling2D(pool_size=2,strides=1)(t) t = layers.Dropout(0.2)(t) #f1 = layers.ZeroPadding2D(padding=(1))(t) f1 = layers.Conv2D(filters=16,kernel_size=(3,3),strides=1,padding='SAME')(t) f1 = layers.BatchNormalization(axis=1)(f1) t = layers.Add()([f1,t]) t = layers.Activation('relu')(t) t = layers.MaxPooling2D(pool_size=2,strides=1)(t) t = layers.Dropout(0.2)(t) t = layers.Conv2D(filters=32,kernel_size=(3,3),strides=2,padding='SAME')(t) t = layers.BatchNormalization(axis=1)(t) f2 = layers.Conv2D(filters=32,kernel_size=(3,3),strides=1,padding='SAME')(t) f2 = layers.BatchNormalization(axis=1)(f2)
def construct_models(feature_extractor, embedding_dim, n_centers_per_class, n_classes, lr, sigma, kernel_type="inverse"): ''' Creates an RBF Model. feature_extractor -> Feature stractor used (CONVNET or RESNET). embedding_dim -> Size of the output Embedding. n_centers_per_class -> Number of Centers per class. n_classes -> Number of Classes. lr -> Learning Rate. sigma -> Regularization parameter. kerney_type -> Used kernel (Inverse, Cosine, Gauss). Returns a training model. ''' if feature_extractor == "RESNET": conv_base = ResNet50(weights='imagenet', include_top=False, input_shape=(200, 200, 3)) input = layers.Input(shape=( 32, 32, 3, )) x = layers.UpSampling2D((2, 2))(input) x = layers.UpSampling2D((2, 2))(x) x = layers.UpSampling2D((2, 2))(x) x = conv_base(x) x = layers.Flatten()(x) x = layers.BatchNormalization()(x) x = layers.Dense(512, activation='relu')(x) x = layers.Dropout(0.5)(x) x = layers.BatchNormalization()(x) x = layers.Dense(embedding_dim, activation='relu')(x) x = layers.BatchNormalization()(x) varkeys_output = RBF(embedding_dim, n_centers_per_class, n_classes, kernel_type)(x) plain_output = layers.Activation('softmax')(layers.Dense(n_classes)(x)) softmax_model = Model(inputs=input, outputs=plain_output) rbf_model = Model(inputs=input, outputs=varkeys_output) embeddings = Model(inputs=input, outputs=x) rbf_model.compile(loss=custom_loss(rbf_model.layers[-1], sigma, 1), optimizer=optimizers.RMSprop(lr=lr), metrics=['accuracy']) softmax_model.compile(loss=keras.losses.categorical_crossentropy, optimizer=optimizers.RMSprop(lr=lr), metrics=['accuracy']) else: layers_dim = [32, 64, 512] input = layers.Input(shape=( 32, 32, 3, )) x = layers.Conv2D(layers_dim[0], (3, 3), padding='same', input_shape=[32, 32, 3])(input) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[0], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[0], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Dropout(0.25)(x) x = layers.Conv2D(layers_dim[1], (3, 3), padding='same')(x) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[1], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Dropout(0.25)(x) x = layers.Flatten()(x) x = layers.Dense(layers_dim[2])(x) x = layers.Activation('relu')(x) x = layers.Dropout(0.5)(x) x = layers.Dense(embedding_dim)(x) x = layers.Activation('relu')(x) x = layers.BatchNormalization()(x) varkeys_output = RBF(embedding_dim, n_centers_per_class, n_classes, kernel_type)(x) plain_output = layers.Activation('softmax')(layers.Dense(n_classes)(x)) softmax_model = Model(inputs=input, outputs=plain_output) rbf_model = Model(inputs=input, outputs=varkeys_output) embeddings = Model(inputs=input, outputs=x) rbf_model.compile(loss=custom_loss(rbf_model.layers[-1], sigma, 1), optimizer=optimizers.RMSprop(lr=lr), metrics=['accuracy']) softmax_model.compile(loss=keras.losses.categorical_crossentropy, optimizer=optimizers.RMSprop(lr=lr), metrics=['accuracy']) return rbf_model, softmax_model, embeddings
def __init__(self, input_shape): """ :param input_shape: [32, 32, 3] """ super(VGG16, self).__init__() weight_decay = 0.000 self.num_classes = 10 model = models.Sequential() model.add( layers.Conv2D(64, (3, 3), padding='same', input_shape=input_shape, kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.3)) model.add( layers.Conv2D(64, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.4)) model.add( layers.Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.5)) model.add(layers.Flatten()) model.add( layers.Dense(512, kernel_regularizer=regularizers.l2(weight_decay))) model.add(layers.Activation('relu')) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(self.num_classes)) # model.add(layers.Activation('softmax')) self.model = model
def construct_model_STL(feature_extractor, embedding_dim, n_centers_per_class, n_classes, lr, gamma): ''' Creates a Soft Triple Loss Model. feature_extractor -> Feature stractor used (CONVNET or RESNET). embedding_dim -> Size of the output Embedding. n_centers_per_class -> Number of Centers per class. n_classes -> Number of Classes. lr -> Learning Rate. gamma -> Gamma parameter according to STL paper. Returns a training model. ''' if feature_extractor == "RESNET": conv_base = ResNet50(weights='imagenet', include_top=False, input_shape=(200, 200, 3)) input = layers.Input(shape=( 32, 32, 3, )) x = layers.UpSampling2D((2, 2))(input) x = layers.UpSampling2D((2, 2))(x) x = layers.UpSampling2D((2, 2))(x) x = conv_base(x) x = layers.Flatten()(x) x = layers.BatchNormalization()(x) x = layers.Dense(512, activation='relu')(x) x = layers.Dropout(0.5)(x) x = layers.BatchNormalization()(x) x = layers.Dense(embedding_dim, activation='relu')(x) x = layers.BatchNormalization()(x) x = RelaxedSimilarity(embedding_dim, n_centers_per_class, n_classes, gamma)(x) output = layers.Softmax()(x) model = Model(inputs=input, outputs=output) model.compile(optimizer=optimizers.RMSprop(lr=lr), loss=SoftTripleLoss(model.layers[-2]), metrics=['acc']) else: layers_dim = [32, 64, 512] input = layers.Input(shape=( 32, 32, 3, )) x = layers.Conv2D(layers_dim[0], (3, 3), padding='same', input_shape=[32, 32, 3])(input) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[0], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[0], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Dropout(0.25)(x) x = layers.Conv2D(layers_dim[1], (3, 3), padding='same')(x) x = layers.Activation('relu')(x) x = layers.Conv2D(layers_dim[1], (3, 3))(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Dropout(0.25)(x) x = layers.Flatten()(x) x = layers.Dense(layers_dim[2])(x) x = layers.Activation('relu')(x) x = layers.Dropout(0.5)(x) x = layers.Dense(embedding_dim)(x) x = layers.Activation('relu')(x) x = layers.BatchNormalization()(x) x = RelaxedSimilarity(embedding_dim, n_centers_per_class, n_classes, gamma)(x) output = layers.Softmax()(x) model = Model(inputs=input, outputs=output) model.compile(optimizer=optimizers.RMSprop(lr=lr), loss=SoftTripleLoss(model.layers[-2]), metrics=['acc']) return model
def train(): max_features = 10000 sequence_length = 250 # Load all datasets raw_train_ds = load_train_dataset() raw_val_ds = load_val_dataset() raw_test_ds = load_test_dataset() # Define the vectorization layer global vectorization_layer vectorization_layer = TextVectorization( standardize='lower_and_strip_punctuation', max_tokens=max_features, output_mode='int', output_sequence_length=sequence_length) # Adapt the vectorization layer vectorization_layer.adapt(raw_train_ds.map(lambda x, y: x)) # Vectorize the dataset train_ds = raw_train_ds.map(text_to_vector) val_ds = raw_val_ds.map(text_to_vector) test_ds = raw_test_ds.map(text_to_vector) auto_tune = tf.data.experimental.AUTOTUNE train_ds = train_ds.cache().prefetch(buffer_size=auto_tune) val_ds = val_ds.cache().prefetch(buffer_size=auto_tune) test_ds = test_ds.cache().prefetch(buffer_size=auto_tune) embedding_dim = 32 # Define the model model = tf.keras.Sequential([ layers.Embedding(max_features + 1, embedding_dim), layers.Dropout(0.2), layers.GlobalAveragePooling1D(), layers.Dropout(0.2), layers.Dense(embedding_dim, activation='relu'), layers.Dropout(0.2), layers.Dense(1) ]) # Compile the model model.compile(loss=losses.BinaryCrossentropy(from_logits=True), optimizer='adam', metrics=tf.metrics.BinaryAccuracy(threshold=0.0)) # Train the model epochs = 10 csv_logger = CSVLogger('training.log') history = model.fit(train_ds, validation_data=val_ds, epochs=epochs, callbacks=[csv_logger]) # Test the model loss, accuracy = model.evaluate(test_ds) print("Model loss against test dataset = ", loss) print("Model accuracy against test dataset = ", accuracy) # Save the model export_model = tf.keras.Sequential([ tf.keras.Input(shape=(1, ), dtype="string"), vectorization_layer, model, layers.Activation('sigmoid') ]) export_model.compile(loss=losses.BinaryCrossentropy(from_logits=False), optimizer="adam", metrics=['accuracy']) export_model.save('saved_model')
def call(self, inputs): return tf.matmul(inputs, self.kernel) def compute_output_shape(self, input_shape): shape = tf.TensorShape(input_shape).as_list() shape[-1] = self.output_dim return tf.TensorShape(shape) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config) model = tf.keras.Sequential([MyLayer(10), layers.Activation('softmax')]) # The compile step specifies the training configuration. model.compile(optimizer=tf.train.RMSPropOptimizer(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # Trains for 5 epochs. import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, batch_size=32, epochs=5)
def create_model(self): """构建model :return t_model: train model :return base_model: pred/test """ input_data = layers.Input(shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1)) # (1600, 200, 1) conv1 = self.conv_layer_no_bias(32)(input_data) drop1 = layers.Dropout(0.05)(conv1) conv2 = self.conv_layer(32)(drop1) pool1 = self.maxpooling_layer(2)(conv2) drop2 = layers.Dropout(0.05)(pool1) conv3 = self.conv_layer(64)(drop2) drop3 = layers.Dropout(0.1)(conv3) conv4 = self.conv_layer(64)(drop3) pool2 = self.maxpooling_layer(2)(conv4) drop4 = layers.Dropout(0.1)(pool2) conv5 = self.conv_layer(128)(drop4) drop5 = layers.Dropout(0.15)(conv5) conv6 = self.conv_layer(128)(drop5) pool3 = self.maxpooling_layer(2)(conv6) drop6 = layers.Dropout(0.15)(pool3) conv7 = self.conv_layer(128)(drop6) drop7 = layers.Dropout(0.2)(conv7) conv8 = self.conv_layer(128)(drop7) pool4 = self.maxpooling_layer(1)(conv8) drop8 = layers.Dropout(0.2)(pool4) conv9 = self.conv_layer(128)(drop8) drop9 = layers.Dropout(0.2)(conv9) conv10 = self.conv_layer(128)(drop9) pool5 = self.maxpooling_layer(1)(conv10) reshape_layer = layers.Reshape((200, 3200))(pool5) drop10 = layers.Dropout(0.3)(reshape_layer) dense1 = self.dense_layer(128, activation='relu')(drop10) drop11 = layers.Dropout(0.3)(dense1) dense2 = self.dense_layer(self.SM_OUTPUT_SIZE)(drop11) y_pred = layers.Activation('softmax')(dense2) # 测试用模型 base_model = models.Model(inputs=input_data, outputs=y_pred, name='base_model') #base_model.summary() # ctc loss y_true = layers.Input(shape=[self.LABEL_MAX_LENGTH]) y_pred = y_pred input_length = layers.Input(shape=[1], dtype='int64') label_length = layers.Input(shape=[1], dtype='int64') # func: ctc_lambda_func ctc_loss = layers.Lambda(self.ctc_lambda_func, output_shape=(1, ), name='ctc_loss')([ y_true, y_pred, input_length, label_length ]) # 训练用模型 t_model = models.Model( inputs=[input_data, y_true, input_length, label_length], outputs=ctc_loss, name='t_model') t_model.summary() # optimizers opt = tf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07) t_model.compile(loss={ 'ctc_loss': lambda y_true, y_pred: y_pred }, optimizer=opt) print('[*Info] Create Model Successful, Compiles Model Successful. ') return t_model, base_model
def build_saveuav_small(self): num_filters = 16 size = self.chip_size input = layers.Input((size, size, 3)) down1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(input) down1pool = layers.Conv2D(filters=num_filters, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(down1) down2 = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(down1pool) down2pool = layers.Conv2D(filters=num_filters * 2, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(down2) down3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(down2pool) down3pool = layers.Conv2D(filters=num_filters * 4, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(down3) y_dilate1 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=1, padding="same", activation="relu")(down3pool) y_dilate2 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=2, padding="same", activation="relu")(y_dilate1) y_dilate3 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=4, padding="same", activation="relu")(y_dilate2) y_dilate4 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=8, padding="same", activation="relu")(y_dilate3) y_dilate5 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=16, padding="same", activation="relu")(y_dilate4) y_dilate6 = layers.Conv2D(filters=num_filters * 8, kernel_size=3, dilation_rate=32, padding="same", activation="relu")(y_dilate5) y_dilate_sum = layers.Add()( [y_dilate1, y_dilate2, y_dilate3, y_dilate4, y_dilate5, y_dilate6]) up3_tr = layers.Conv2DTranspose(filters=num_filters * 4, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_dilate_sum) y_up3_tr_add = layers.Add()([up3_tr, down3]) y_up3 = layers.Conv2D(filters=num_filters * 4, kernel_size=3, activation="relu", padding="same")(y_up3_tr_add) up2_tr = layers.Conv2DTranspose(filters=num_filters * 2, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_up3) y_up2_tr_add = layers.Add()([up2_tr, down2]) y_up2 = layers.Conv2D(filters=num_filters * 2, kernel_size=3, activation="relu", padding="same")(y_up2_tr_add) up1_tr = layers.Conv2DTranspose(filters=num_filters, kernel_size=3, strides=(2, 2), activation="relu", padding="same")(y_up2) y_up1_tr_add = layers.Add()([up1_tr, down1]) y_up1 = layers.Conv2D(filters=num_filters, kernel_size=3, activation="relu", padding="same")(y_up1_tr_add) final_conv = layers.Conv2D(filters=6, kernel_size=1)(y_up1) x = layers.Activation("softmax")(final_conv) model = models.Model(input, x) return model