def ResNet(input_shape=None, classes=10, block='bottleneck', residual_unit='v2', repetitions=None, initial_filters=16, activation='softmax', include_top=True, input_tensor=None, dropout=None, transition_dilation_rate=(1, 1), initial_strides=(1, 1), initial_kernel_size=(3, 3), initial_pooling=None, final_pooling=None, top='classification'): """Builds a custom ResNet like architecture. Defaults to ResNet50 v2. Args: input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(224, 224, 3)` (with `channels_last` dim ordering) or `(3, 224, 224)` (with `channels_first` dim ordering). It should have exactly 3 dimensions, and width and height should be no smaller than 8. E.g. `(224, 224, 3)` would be one valid value. classes: The number of outputs at final softmax layer block: The block function to use. This is either `'basic'` or `'bottleneck'`. The original paper used `basic` for layers < 50. repetitions: Number of repetitions of various block units. At each block unit, the number of filters are doubled and the input size is halved. Default of None implies the ResNet50v2 values of [3, 4, 6, 3]. residual_unit: the basic residual unit, 'v1' for conv bn relu, 'v2' for bn relu conv. See [Identity Mappings in Deep Residual Networks](https://arxiv.org/abs/1603.05027) for details. dropout: None for no dropout, otherwise rate of dropout from 0 to 1. Based on [Wide Residual Networks.(https://arxiv.org/pdf/1605.07146) paper. transition_dilation_rate: Dilation rate for transition layers. For semantic segmentation of images use a dilation rate of (2, 2). initial_strides: Stride of the very first residual unit and MaxPooling2D call, with default (2, 2), set to (1, 1) for small images like cifar. initial_kernel_size: kernel size of the very first convolution, (7, 7) for imagenet and (3, 3) for small image datasets like tiny imagenet and cifar. See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details. initial_pooling: Determine if there will be an initial pooling layer, 'max' for imagenet and None for small image datasets. See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details. final_pooling: Optional pooling mode for feature extraction at the final model layer when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional layer. - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. top: Defines final layers to evaluate based on a specific problem type. Options are 'classification' for ImageNet style problems, 'segmentation' for problems like the Pascal VOC dataset, and None to exclude these layers entirely. Returns: The keras `Model`. """ if activation not in ['softmax', 'sigmoid', None]: raise ValueError('activation must be one of "softmax", "sigmoid", or None') if activation == 'sigmoid' and classes != 1: raise ValueError('sigmoid activation can only be used when classes = 1') if repetitions is None: repetitions = [3, 4, 6, 3] # Determine proper input shape # input_shape = _obtain_input_shape(input_shape, # default_size=32, # min_size=8, # data_format=K.image_data_format(), # require_flatten=include_top) _handle_dim_ordering() if len(input_shape) != 3: raise Exception("Input shape should be a tuple (nb_channels, nb_rows, nb_cols)") if block == 'basic': block_fn = basic_block elif block == 'bottleneck': block_fn = bottleneck elif isinstance(block, six.string_types): block_fn = _string_to_function(block) else: block_fn = block if residual_unit == 'v2': residual_unit = _bn_relu_conv elif residual_unit == 'v1': residual_unit = _conv_bn_relu elif isinstance(residual_unit, six.string_types): residual_unit = _string_to_function(residual_unit) else: residual_unit = residual_unit # Permute dimension order if necessary if K.image_data_format() == 'channels_first': input_shape = (input_shape[1], input_shape[2], input_shape[0]) # Determine proper input shape # input_shape = _obtain_input_shape(input_shape, # default_size=32, # min_size=8, # data_format=K.image_data_format(), # require_flatten=include_top) img_input = Input(shape=input_shape, tensor=input_tensor) x = _conv_bn_relu(filters=initial_filters, kernel_size=initial_kernel_size, strides=initial_strides)(img_input) if initial_pooling == 'max': x = MaxPooling2D(pool_size=(3, 3), strides=initial_strides, padding="same")(x) block = x filters = initial_filters for i, r in enumerate(repetitions): transition_dilation_rates = [transition_dilation_rate] * r transition_strides = [(1, 1)] * r if transition_dilation_rate == (1, 1): transition_strides[0] = (2, 2) block = _residual_block(block_fn, filters=filters, stage=i, blocks=r, is_first_layer=(i == 0), dropout=dropout, transition_dilation_rates=transition_dilation_rates, transition_strides=transition_strides, residual_unit=residual_unit)(block) filters *= 2 # Last activation x = _bn_relu(block) # Classifier block if include_top and top is 'classification': x = GlobalAveragePooling2D()(x) x = Dense(units=classes, activation=activation, kernel_initializer="he_normal", kernel_regularizer=l2(L2_WEIGHT_DECAY), bias_regularizer=l2(L2_WEIGHT_DECAY))(x) elif include_top and top is 'segmentation': x = Conv2D(classes, (1, 1), activation='linear', padding='same')(x) if K.image_data_format() == 'channels_first': channel, row, col = input_shape else: row, col, channel = input_shape x = Reshape((row * col, classes))(x) x = Activation(activation)(x) x = Reshape((row, col, classes))(x) elif final_pooling == 'avg': x = GlobalAveragePooling2D()(x) elif final_pooling == 'max': x = GlobalMaxPooling2D()(x) model = Model(inputs=img_input, outputs=x) return model
np.random.seed(23456) tf.random.set_seed(123) # Initiating an empty neural network cnn_model = Sequential(name='cnn_1') # Adding convolutional layer cnn_model.add( Conv2D(filters=16, kernel_size=(3, 3), activation='relu', input_shape=(128, 660, 1))) # Adding max pooling layer cnn_model.add(MaxPooling2D(pool_size=(2, 4))) # Adding convolutional layer cnn_model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu')) # Adding max pooling layer cnn_model.add(MaxPooling2D(pool_size=(2, 4))) # Adding a flattened layer to input our image data cnn_model.add(Flatten()) # Adding a dense layer with 64 neurons cnn_model.add(Dense(64, activation='relu')) # Adding a dropout layer for regularization cnn_model.add(Dropout(0.25))
inputArray = inputArray[:i] outputArray = outputArray[:i] return (inputArray, outputArray) #model model = Sequential() #normalizing and cropping model.add(Input((280,640,2))) model.add(Lambda(lambda x:x/255.0)) #model.add(Cropping2D(cropping=((206,72), (0,0)))) # 43%, 15% #layer 1 model.add(Conv2D(32, (19,19), activation='relu', kernel_regularizer=ft.keras.regularizers.l2())) model.add(MaxPooling2D(3,3)) model.add(Dropout(rate=0.3)) #layer 1 model.add(Conv2D(32, (15,15), activation='relu', kernel_regularizer=ft.keras.regularizers.l2())) model.add(MaxPooling2D(3,3)) model.add(Dropout(rate=0.3)) #layer 2 model.add(Conv2D(32, (5,5), activation='relu', kernel_regularizer=ft.keras.regularizers.l2())) model.add(MaxPooling2D(3,3)) model.add(Dropout(rate=0.3)) model.add(Flatten()) #fc 1 model.add(Dense(32, activation=ft.nn.relu))
def init(self, img_h, img_w): #1365x2048 concat_axis = 3 self.img_h = img_h self.img_w = img_w # contracting path #self.pad1 = SymmetricPadding2D(output_dim=(512, 512, 3), kernel=5, padding=[pad_size, pad_size], input_shape=(512, 512, 3)) self.conv1 = Conv2D(16, (5,5), (1,1), padding="same", activation="selu") #1365x2048x16 self.batch1 = BatchNormalization() self.pool1 = MaxPooling2D(pool_size=(2, 2)) self.conv2 = Conv2D(32, (5,5), (2,2), padding="same", activation="selu") #256x256x32 self.batch2 = BatchNormalization() self.pool2 = MaxPooling2D(pool_size=(2, 2)) self.conv3 = Conv2D(64, (5,5), (2,2), padding="same", activation="selu") #128x128x64 self.batch3 = BatchNormalization() self.pool3 = MaxPooling2D(pool_size=(2, 2)) self.conv4 = Conv2D(128, (5,5), (2,2), padding="same", activation="selu") #64x64x128 self.batch4 = BatchNormalization() self.pool4 = MaxPooling2D(pool_size=(2, 2)) self.conv5 = Conv2D(128, (5,5), (2,2), padding="same", activation="selu") #32x32x128 self.batch5 = BatchNormalization() # global features self.pool5 = MaxPooling2D(pool_size=(2, 2)) self.conv6 = Conv2D(128, (5,5), (2,2), padding="same", activation="selu") #16x16x128 self.batch6 = BatchNormalization() self.pool6 = MaxPooling2D(pool_size=(2, 2)) self.conv7 = Conv2D(128, (5,5), (2,2), padding="same", activation="selu") #8x8x128 self.batch7 = BatchNormalization() # fc -> selu -> fc self.conv8 = Conv2D(128, (8,8), (1,1), padding="valid", activation="selu") #1x1x128 self.conv9 = Conv2D(128, (1,1), (1,1), padding="valid") #1x1x128 # expanding path self.conv10 = Conv2D(128, (3,3), (1,1), padding="same") self.global_concat = GlobalConcat((1, 512, 512, 128)) self.conv11 = Conv2D(128, (1,1), (1,1), padding="same", activation="selu") self.batch11 = BatchNormalization() self.conv12 = Conv2D(128, (3,3), (1,1), padding="same") self.resize12 = Lambda(lambda x: tf.image.resize_bilinear(x, size=(x.get_shape()*2), align_corners=True)) self.concat12 = Concatenate(axis=concat_axis) self.act12 = Activation('selu') self.batch12 = BatchNormalization() self.conv13 = Conv2D(128, (3,3), (1,1), padding="same") self.resize13 = Lambda(lambda x: tf.image.resize_bilinear(x, size=(x.get_shape()*2), align_corners=True)) self.concat13 = Concatenate(axis=concat_axis) self.act13 = Activation('selu') self.batch13 = BatchNormalization() self.conv14 = Conv2D(64, (3,3), (1,1), padding="same") self.resize14 = Lambda(lambda x: tf.image.resize_bilinear(x, size=(x.get_shape()*2), align_corners=True)) self.concat14 = Concatenate(axis=concat_axis) self.act14 = Activation('selu') self.batch14 = BatchNormalization() self.conv15 = Conv2D(32, (3,3), (1,1), padding="same") self.resize15 = Lambda(lambda x: tf.image.resize_bilinear(x, size=(x.get_shape()*2), align_corners=True)) self.concat15 = Concatenate(axis=concat_axis) self.act15 = Activation('selu') self.batch15 = BatchNormalization() self.conv16 = Conv2D(16, (3,3), (1,1), padding="same") self.act16 = Activation('selu') self.batch16 = BatchNormalization() self.conv17 = Conv2D(3, (3,3), (1,1), padding="same") self.add = Add()
onehot = [0 for _ in range(len(LETTERSTR))] num = LETTERSTR.find(letter) onehot[num] = 1 labellist.append(onehot) return labellist # Create CNN Model print("Creating CNN model...") inp = Input((60, 200, 3)) out = inp out = Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(out) out = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(out) out = BatchNormalization()(out) out = MaxPooling2D(pool_size=(2, 2))(out) out = Dropout(0.3)(out) out = Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(out) out = Conv2D(filters=64, kernel_size=(3, 3), activation='relu')(out) out = BatchNormalization()(out) out = MaxPooling2D(pool_size=(2, 2))(out) out = Dropout(0.3)(out) out = Conv2D(filters=128, kernel_size=(3, 3), padding='same', activation='relu')(out) out = Conv2D(filters=128, kernel_size=(3, 3), activation='relu')(out) out = BatchNormalization()(out) out = MaxPooling2D(pool_size=(2, 2))(out) out = Dropout(0.3)(out)
def VGG16(include_top=True, weights='vggface', input_tensor=None, input_shape=None, pooling=None, classes=2622): input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=48, data_format=K.image_data_format(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # Block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_1')( img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x) # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_1')( x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_2')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(x) # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_1')( x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_2')( x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(x) # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_1')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_2')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(x) # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_1')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_2')( x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_3')( x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool5')(x) if include_top: # Classification block x = Flatten(name='flatten')(x) x = Dense(4096, name='fc6')(x) x = Activation('relu', name='fc6/relu')(x) x = Dense(4096, name='fc7')(x) x = Activation('relu', name='fc7/relu')(x) x = Dense(classes, name='fc8')(x) x = Activation('softmax', name='fc8/softmax')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='vggface_vgg16') # load weights if weights == 'vggface': if include_top: weights_path = get_file('rcmalli_vggface_tf_vgg16.h5', utils. VGG16_WEIGHTS_PATH, cache_subdir=utils.VGGFACE_DIR) else: weights_path = get_file('rcmalli_vggface_tf_notop_vgg16.h5', utils.VGG16_WEIGHTS_PATH_NO_TOP, cache_subdir=utils.VGGFACE_DIR) model.load_weights(weights_path, by_name=True) if K.backend() == 'theano': layer_utils.convert_all_kernels_in_model(model) if K.image_data_format() == 'channels_first': if include_top: maxpool = model.get_layer(name='pool5') shape = maxpool.output_shape[1:] dense = model.get_layer(name='fc6') layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first') if K.backend() == 'tensorflow': warnings.warn('You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image data format convention ' '(`image_data_format="channels_first"`). ' 'For best performance, set ' '`image_data_format="channels_last"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') return model
def build_unet(self): input_img = Input(shape=self.img_shape) # (N,240,240,1) -> (N,120,120,64) conv1 = Conv2D(32, 3, 1, padding='same')(input_img) conv1 = InstanceNormalization()(conv1) conv1 = ReLU()(conv1) conv1 = Conv2D(32, 3, 1, padding='same')(conv1) conv1 = InstanceNormalization()(conv1) conv1 = ReLU()(conv1) pool1 = MaxPooling2D()(conv1) # (N,120,120,64) -> (N,60,60,128) conv2 = Conv2D(64, 3, 1, padding='same')(pool1) conv2 = InstanceNormalization()(conv2) conv2 = ReLU()(conv2) conv2 = Conv2D(64, 3, 1, padding='same')(conv2) conv2 = InstanceNormalization()(conv2) conv2 = ReLU()(conv2) pool2 = MaxPooling2D()(conv2) # (N,60,60,128) -> (N,30,30,256) conv3 = Conv2D(128, 3, 1, padding='same')(pool2) conv3 = InstanceNormalization()(conv3) conv3 = ReLU()(conv3) conv3 = Conv2D(128, 3, 1, padding='same')(conv3) conv3 = InstanceNormalization()(conv3) conv3 = ReLU()(conv3) pool3 = MaxPooling2D()(conv3) # (N,30,30,128) -> (N,15,15,256) conv4 = Conv2D(256, 3, 1, padding='same')(pool3) conv4 = InstanceNormalization()(conv4) conv4 = ReLU()(conv4) conv4 = Conv2D(256, 3, 1, padding='same')(conv4) conv4 = InstanceNormalization()(conv4) conv4 = ReLU()(conv4) pool4 = MaxPooling2D()(conv4) # (N,15,15,256) -> (N,15,15,512) conv5 = Conv2D(512, 3, 1, padding='same')(pool4) conv5 = InstanceNormalization()(conv5) conv5 = ReLU()(conv5) conv5 = Conv2D(512, 3, 1, padding='same')(conv5) conv5 = InstanceNormalization()(conv5) conv5 = ReLU()(conv5) # (N,15,15,512) -> (N,30,30,256) up1 = UpSampling2D(size=(2, 2))(conv5) conv6 = Concatenate(axis=-1)([up1, conv4]) conv6 = Conv2D(256, 3, 1, padding='same')(conv6) conv6 = InstanceNormalization()(conv6) conv6 = ReLU()(conv6) conv6 = Conv2D(256, 3, 1, padding='same')(conv6) conv6 = InstanceNormalization()(conv6) conv6 = ReLU()(conv6) # (N,30,30,256) -> (N,60,60,128) up2 = UpSampling2D(size=(2, 2))(conv6) conv7 = Concatenate(axis=-1)([up2, conv3]) conv7 = Conv2D(128, 3, 1, padding='same')(conv7) conv7 = InstanceNormalization()(conv7) conv7 = ReLU()(conv7) conv7 = Conv2D(128, 3, 1, padding='same')(conv7) conv7 = InstanceNormalization()(conv7) conv7 = ReLU()(conv7) # (N,60,60,128) -> (N,120,120,64) up3 = UpSampling2D(size=(2, 2))(conv7) conv8 = Concatenate(axis=-1)([up3, conv2]) conv8 = Conv2D(64, 3, 1, padding='same')(conv8) conv8 = InstanceNormalization()(conv8) conv8 = ReLU()(conv8) conv8 = Conv2D(64, 3, 1, padding='same')(conv8) conv8 = InstanceNormalization()(conv8) conv8 = ReLU()(conv8) # (N,120,120,64) -> (N,240,240,32) up4 = UpSampling2D(size=(2, 2))(conv8) conv9 = Concatenate(axis=-1)([up4, conv1]) conv9 = Conv2D(32, 3, 1, padding='same')(conv9) conv9 = InstanceNormalization()(conv9) conv9 = ReLU()(conv9) conv9 = Conv2D(32, 3, 1, padding='same')(conv9) conv9 = InstanceNormalization()(conv9) conv9 = ReLU()(conv9) output = Conv2D(1, 1, 1, padding='same', activation='sigmoid')(conv9) self.unet = Model(input_img, output) self.unet.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=[utils.f1]) return self.unet
def init_model(self, input_shape, num_classes, **kwargs): layers = 5 filters_size = [64, 128, 256, 512, 512] kernel_size = (3, 3) pool_size = [(2, 2), (2, 2), (2, 2), (4, 1), (4, 1)] freq_axis = 2 channel_axis = 3 channel_size = 128 min_size = min(input_shape[:2]) melgram_input = Input(shape=input_shape) # x = ZeroPadding2D(padding=(0, 37))(melgram_input) x = Reshape((input_shape[0], input_shape[1], 1))(melgram_input) x = BatchNormalization(axis=freq_axis, name='bn_0_freq')(x) # Conv block 1 x = Convolution2D(filters=filters_size[0], kernel_size=kernel_size, padding='same', name='conv1')(x) x = ELU()(x) x = BatchNormalization(axis=channel_axis, name='bn1')(x) x = MaxPooling2D(pool_size=pool_size[0], strides=pool_size[0], name='pool1')(x) x = Dropout(0.1, name='dropout1')(x) min_size = min_size // pool_size[0][0] for layer in range(1, layers): min_size = min_size // pool_size[layer][0] if min_size < 1: break x = Convolution2D(filters=filters_size[layer], kernel_size=kernel_size, padding='same', name=f'conv{layer + 1}')(x) x = ELU()(x) x = BatchNormalization(axis=channel_axis, name=f'bn{layer + 1}')(x) x = MaxPooling2D(pool_size=pool_size[layer], strides=pool_size[layer], name=f'pool{layer + 1}')(x) x = Dropout(0.1, name=f'dropout{layer + 1}')(x) x = Reshape((-1, channel_size))(x) gru_units = 32 if num_classes > 32: gru_units = int(num_classes * 1.5) # GRU block 1, 2, output x = CuDNNGRU(gru_units, return_sequences=True, name='gru1')(x) x = CuDNNGRU(gru_units, return_sequences=False, name='gru2')(x) x = Dropout(0.3)(x) outputs = Dense(num_classes, activation='softmax', name='output')(x) model = TFModel(inputs=melgram_input, outputs=outputs) optimizer = optimizers.Adam( # learning_rate=1e-3, lr=1e-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=1e-4, amsgrad=True) model.compile(optimizer=optimizer, loss="sparse_categorical_crossentropy", metrics=['accuracy']) model.summary() self._model = model self.is_init = True
def VGG16(save_dir): VGG16 = Sequential() VGG16.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(224, 224, 3), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add(MaxPooling2D(pool_size=(2, 2))) VGG16.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add(MaxPooling2D(pool_size=(2, 2))) VGG16.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add(MaxPooling2D(pool_size=(2, 2))) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add(MaxPooling2D(pool_size=(2, 2))) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer='uniform')) VGG16.add(MaxPooling2D(pool_size=(2, 2))) VGG16.add(Flatten()) VGG16.add(Dense(4096, activation='relu')) VGG16.add(Dropout(0.5)) VGG16.add(Dense(4096, activation='relu')) VGG16.add(Dropout(0.5)) VGG16.add(Dense(1000, activation='softmax')) VGG16.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) VGG16.summary() save_dir += 'VGG16.h5' return VGG16
1)) # shape ((867, 1, 7500, 1)) y_train_CNN = utils.to_categorical(y_train) # shape (867, 6) X_test_CNN = X_test_ss.reshape((X_test_ss.shape[0], 1, X_test_ss.shape[1], 1)) # shape ((217, 1, 7500, 1)) y_test_CNN = y_test y_test_CNN = utils.to_categorical(y_test) # shape (217, 6) print(X_train_CNN.shape, X_test_CNN.shape, y_train_CNN.shape, y_test_CNN.shape) conv = Sequential() conv.add( Conv2D(64, (1, 3), activation='relu', input_shape=(1, N_channels * 30 * FreqSample // step, 1))) conv.add(MaxPooling2D((1, 2))) conv.add(Conv2D(128, (1, 3), activation='relu')) conv.add(MaxPooling2D((1, 2))) conv.add(Conv2D(256, (1, 3), activation='relu')) conv.add(MaxPooling2D((1, 2))) conv.add(Flatten()) conv.add(Dense(64, activation='relu')) conv.add(Dropout(0.5)) conv.add(Dense(5, activation='softmax')) conv.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
def build_autoencoder(self, param): autoencoder = None input_img = Input(shape=(param.get('image_size'), param.get('image_size'), param.get('image_channels')), name='input') x = Conv2D(256, (param.get('cae_conv_size'), param.get('cae_conv_size')), activation='relu', padding='same')(input_img) # tanh? x = MaxPooling2D( (param.get('cae_max_pool_size'), param.get('cae_max_pool_size')), padding='same')(x) x = Conv2D(128, (param.get('cae_conv_size'), param.get('cae_conv_size')), activation='relu', padding='same')(x) x = MaxPooling2D( (param.get('cae_max_pool_size'), param.get('cae_max_pool_size')), padding='same')(x) x = Conv2D(128, (param.get('cae_conv_size'), param.get('cae_conv_size')), activation='relu', padding='same')(x) x = MaxPooling2D( (param.get('cae_max_pool_size'), param.get('cae_max_pool_size')), padding='same')(x) x = Flatten()(x) encoded = Dense(param.get('code_size'), name='encoded')(x) print('encoded shape ', encoded.shape) ims = 8 first = True x = Dense(int(ims * ims), activation='relu')(encoded) x = Reshape(target_shape=(ims, ims, 1))(x) # -12 while ims != param.get('image_size'): x = Conv2D( int(ims * ims / 2), (param.get('cae_conv_size'), param.get('cae_conv_size')), activation='relu', padding='same')(x) x = UpSampling2D((param.get('cae_max_pool_size'), param.get('cae_max_pool_size')))(x) ims = ims * param.get('cae_max_pool_size') decoded = Conv2D( param.get('image_channels'), (param.get('cae_conv_size'), param.get('cae_conv_size')), activation='sigmoid', padding='same', name='decoded')(x) print('decoded shape ', decoded.shape) autoencoder = Model(input_img, decoded) autoencoder.compile(optimizer='adam', loss='mean_squared_error') # Create a separate encoder model encoder = Model(input_img, encoded) encoder.compile(optimizer='adam', loss='mean_squared_error') encoder.summary() # Create a separate decoder model decoder_inp = Input(shape=(param.get('code_size'), )) # decoder_inp = Input(shape=encoded.output_shape) enc_layer_idx = utils.getLayerIndexByName(autoencoder, 'encoded') print('encoder layer idx ', enc_layer_idx) decoder_layer = autoencoder.layers[enc_layer_idx + 1](decoder_inp) for i in range(enc_layer_idx + 2, len(autoencoder.layers)): decoder_layer = autoencoder.layers[i](decoder_layer) decoder = Model(decoder_inp, decoder_layer) decoder.compile(optimizer='adam', loss='mean_squared_error') decoder.summary() return autoencoder, encoder, decoder
def unet2d(input_shape=(224, 224, 1), dropout_rate=0.5): """Instantiate two-dimensional U-Net architecture.""" conv_kwds = { 'kernel_size': (3, 3), 'activation': 'relu', 'padding': 'same', 'kernel_regularizer': l2(0.1), } conv_transpose_kwds = { 'kernel_size': (2, 2), 'strides': (2, 2), 'padding': 'same', 'kernel_regularizer': l2(0.1), } inputs = Input(shape=input_shape) conv1 = Conv2D(64, **conv_kwds)(inputs) conv1 = Conv2D(64, **conv_kwds)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, **conv_kwds)(pool1) conv2 = Conv2D(128, **conv_kwds)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, **conv_kwds)(pool2) conv3 = Conv2D(256, **conv_kwds)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, **conv_kwds)(pool3) conv4 = Conv2D(512, **conv_kwds)(conv4) drop4 = Dropout(dropout_rate)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, **conv_kwds)(pool4) conv5 = Conv2D(1024, **conv_kwds)(conv5) drop5 = Dropout(dropout_rate)(conv5) t = Conv2DTranspose(512, **conv_transpose_kwds)(drop5) up6 = Concatenate(axis=-1)([t, drop4]) conv6 = Conv2D(512, **conv_kwds)(up6) conv6 = Conv2D(512, **conv_kwds)(conv6) t = Conv2DTranspose(256, **conv_transpose_kwds)(conv6) up7 = Concatenate(axis=-1)([t, conv3]) conv7 = Conv2D(256, **conv_kwds)(up7) conv7 = Conv2D(256, **conv_kwds)(conv7) t = Conv2DTranspose(128, **conv_transpose_kwds)(conv7) up8 = Concatenate(axis=-1)([t, conv2]) conv8 = Conv2D(128, **conv_kwds)(up8) conv8 = Conv2D(128, **conv_kwds)(conv8) t = Conv2DTranspose(64, **conv_transpose_kwds)(conv8) up9 = Concatenate(axis=-1)([t, conv1]) conv9 = Conv2D(64, **conv_kwds)(up9) conv9 = Conv2D(64, **conv_kwds)(conv9) conv10 = Conv2D(1, (1, 1), activation='sigmoid', kernel_regularizer=l2(0.1))(conv9) return Model(inputs=[inputs], outputs=[conv10])
def create_model(learning_rate, num_dense_layers, num_dense_nodes, activation): """ Hyper-parameters: learning_rate: Learning-rate for the optimizer. num_dense_layers: Number of dense layers. num_dense_nodes: Number of nodes in each dense layer. activation: Activation function for all layers. """ # Start construction of a Keras Sequential model. model = Sequential() # Add an input layer which is similar to a feed_dict in TensorFlow. # Note that the input-shape must be a tuple containing the image-size. model.add(InputLayer(input_shape=(img_size_flat, ))) # The input from MNIST is a flattened array with 784 elements, # but the convolutional layers expect images with shape (28, 28, 1) model.add(Reshape(img_shape_full)) # First convolutional layer. # There are many hyper-parameters in this layer, but we only # want to optimize the activation-function in this example. model.add( Conv2D(kernel_size=5, strides=1, filters=16, padding='same', activation=activation, name='layer_conv1')) model.add(MaxPooling2D(pool_size=2, strides=2)) # Second convolutional layer. # Again, we only want to optimize the activation-function here. model.add( Conv2D(kernel_size=5, strides=1, filters=36, padding='same', activation=activation, name='layer_conv2')) model.add(MaxPooling2D(pool_size=2, strides=2)) # Flatten the 4-rank output of the convolutional layers # to 2-rank that can be input to a fully-connected / dense layer. model.add(Flatten()) # Add fully-connected / dense layers. # The number of layers is a hyper-parameter we want to optimize. for i in range(num_dense_layers): # Name of the layer. This is not really necessary # because Keras should give them unique names. name = 'layer_dense_{0}'.format(i + 1) # Add the dense / fully-connected layer to the model. # This has two hyper-parameters we want to optimize: # The number of nodes and the activation function. model.add(Dense(num_dense_nodes, activation=activation, name=name)) # Last fully-connected / dense layer with softmax-activation # for use in classification. model.add(Dense(num_classes, activation='softmax')) # Use the Adam method for training the network. # We want to find the best learning-rate for the Adam method. optimizer = Adam(lr=learning_rate) # In Keras we need to compile the model so it can be trained. model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) return model
def cifar10_complicated_ensemble_submodel4( input_shape=None, input_tensor=None, n_classes=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar10 network. :param n_classes: used in order to be compatible with the main script. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras functional API Model. """ inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 1e-7 # Block1. x = Conv2D(32, (3, 3), padding='same', activation='relu', name='block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x = BatchNormalization(name='block1_batch-norm1')(x) x = Conv2D(32, (3, 3), padding='same', activation='relu', name='block1_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block1_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block1_pool')(x) # Block2 x = Conv2D(64, (3, 3), padding='same', activation='relu', name='block2_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm1')(x) x = Conv2D(64, (3, 3), padding='same', activation='relu', name='block2_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block2_pool')(x) # Block3 x = Conv2D(128, (3, 3), padding='same', activation='relu', name='block3_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm1')(x) x = Conv2D(128, (3, 3), padding='same', activation='relu', name='block3_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block3_pool')(x) # Add top layers. x = Flatten(name='flatten')(x) outputs = Dense(n_classes, activation='softmax', name='softmax_outputs')(x) # Create Submodel 3. model = Model(inputs, outputs, name='cifar10_complicated_ensemble_submodel3') # Load weights, if they exist. load_weights(weights_path, model) return model
def build_model(initial_filters, size_final_dense, initializer): # Input Layer image_input = Input(shape=( image_height, image_width, image_depth )) # Final element is number of channels, set as 1 for greyscale #x = BatchNormalization()(image_input) ### Block 1 # Convolutional Layer 1 x = Conv2D(filters=initial_filters, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(image_input) #x = BatchNormalization()(x) # Convolutional Layer 2 x = Conv2D(filters=initial_filters, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(x) #x = BatchNormalization()(x) # Pooling Layer 1 - halve spatial dimension x = MaxPooling2D(pool_size=(2, 2))(x) ### Block 2 # Convolutional Layer 3 - double number of filters x = Conv2D(filters=initial_filters * 2, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(x) #x = BatchNormalization()(x) # Convolutional Layer 4 x = Conv2D(filters=initial_filters * 2, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(x) #x = BatchNormalization()(x) # Pooling Layer 2 - halve spatial dimension x = MaxPooling2D(pool_size=(2, 2))(x) ### Block 3 # Convolutional Layer 5 - double number of filters x = Conv2D(filters=initial_filters * 2 * 2, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(x) #x = BatchNormalization()(x) # Convolutional Layer 6 x = Conv2D(filters=initial_filters * 2 * 2, kernel_initializer=initializer, kernel_size=(3, 3), activation='relu', padding='same')(x) #x = BatchNormalization()(x) # Pooling Layer 3 - halve spatial dimension x = MaxPooling2D(pool_size=(2, 2))(x) # Dense Layer x = Flatten()(x) x = Dense(size_final_dense, activation='relu', kernel_initializer=initializer)(x) # Output Layer out = Dense(num_classes, activation='softmax', kernel_initializer=initializer)( x) # Task is binary classification model = Model(image_input, out) return (model)
def attentionModule(input): residual = input x = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(input) x = _bn_relu(x) x = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) ## softmax branch: bottom-up x = MaxPooling2D(pool_size=(3, 3), strides=(1, 1))(x) x = Conv2D(16, kernel_size=(3, 3), dilation_rate=(4,8), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = _bn_relu(x) out_skip1 = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) out_skip1 = _bn_relu(out_skip1) print(out_skip1.shape) x = MaxPooling2D(pool_size=(3, 3), strides=(1, 1))(x) x = Conv2D(16, kernel_size=(3, 3), dilation_rate=(8,16), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = _bn_relu(x) out_skip2 = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) out_skip2 = _bn_relu(out_skip2) print(out_skip2.shape) x = MaxPooling2D(pool_size=(3, 3), strides=(1, 1))(x) x = Conv2D(16, kernel_size=(3, 3), dilation_rate=(16,32), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = _bn_relu(x) out_skip3 = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) out_skip3 = _bn_relu(out_skip3) print(out_skip3.shape) x = MaxPooling2D(pool_size=(3, 3), strides=(1, 1))(x) x = Conv2D(16, kernel_size=(3, 3), dilation_rate=(32,64), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = _bn_relu(x) out_skip4 = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) out_skip4 = _bn_relu(out_skip4) print(out_skip4.shape) x = MaxPooling2D(pool_size=(3, 3), strides=(1, 2))(x) x = Conv2D(16, kernel_size=(3, 3), dilation_rate=(64,128), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = _bn_relu(x) x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) #top down print(x.shape) #x = UpSamplingUnet(size=(905/454,1), interpolation='bilinear')(x) x = Lambda(resize_like, arguments={'ref_tensor':(137,851)})(x) x = Add()([x, out_skip4]) #x += out_skip4 x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) #x = UpSamplingUnet(size=((969/907),37/5), interpolation='bilinear')(x) x = Lambda(resize_like, arguments={'ref_tensor':(201,979)})(x) x = Add()([x, out_skip3]) #x += out_skip3 x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) #x = UpSampling2D(size=(1,1), interpolation='bilinear')(x) x = Lambda(resize_like, arguments={'ref_tensor':(233,1043)})(x) x = Add()([x, out_skip2]) #x += out_skip2 x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) #x = UpSampling2D(size=(1,1), interpolation='bilinear')(x) x = Lambda(resize_like, arguments={'ref_tensor':(249,1075)})(x) x = Add()([x, out_skip1]) #x += out_skip1 x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) #x = UpSampling2D(size=(1,1), interpolation='bilinear')(x) x = Lambda(resize_like, arguments={'ref_tensor':(257,1091)})(x) # x = _bn_relu(x) # x = Conv2D(4, kernel_size=(1, 1), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) # x = _bn_relu(x) # x = Conv2D(1, kernel_size=(1, 1), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) x = Conv2D(32, kernel_size=(1, 1), strides=(1,1), padding="same", use_bias=False)(x) x = _bn_relu(x) x = Conv2D(32, kernel_size=(1, 1), strides=(1,1), padding="same", use_bias=False)(x) weight = Activation('sigmoid')(x) #output of softmax layer is weight x = Multiply()([weight, residual]) x = Add()([x, residual]) return x, weight
def cifar10_student_strong(n_classes: int, input_shape=None, input_tensor=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar10 strong student network. :param n_classes: the number of classes. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained cifar10 tiny network's weights. :return: Keras functional Model. """ inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 1e-4 # Block1. x = Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x = BatchNormalization(name='block1_batch-norm1')(x) x = Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block1_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block1_pool')(x) x = Dropout(0.2, name='block1_dropout', seed=0)(x) # Block2. x = Conv2D(64, (3, 3), padding='same', activation='elu', name='block2_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm1')(x) x = Conv2D(64, (3, 3), padding='same', activation='elu', name='block2_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block2_pool')(x) x = Dropout(0.3, name='block2_dropout', seed=0)(x) # Add top layers. x = Flatten()(x) x = Dense(n_classes)(x) outputs = Activation('softmax', name='softmax')(x) # Create model. model = Model(inputs, outputs, name='cifar10_student_strong') # Load weights, if they exist. load_weights(weights_path, model) return model
from tensorflow.python.keras.preprocessing.image import load_img from tensorflow.python.keras.preprocessing.image import img_to_array import numpy as np from tensorflow.python.keras.models import load_model import cv2 import numpy #import torchvision.datasets.imagenet as imagenet #to include models like Squeezenet,Alexnet model = vgg19.VGG19(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) #model.cuda() # add new classifier layers x = model.output x = MaxPooling2D()(x) for layer in model.layers: layer.trainable = False x = Dense(units=256, activation="relu", kernel_regularizer=regularizers.l2(0.01))(x) x = Dropout(0.4)(x) x = Dense(units=256, activation="relu", kernel_regularizer=regularizers.l2(0.01))(x) x = Dropout(0.4)(x) x = Flatten()(x) output = Dense(units=4, activation="softmax")(x) model = Model(inputs=model.input, outputs=output)
def SENET50(include_top=True, weights='vggface', input_tensor=None, input_shape=None, pooling=None, classes=8631): input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=197, data_format=K.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if K.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 x = Conv2D( 64, (7, 7), use_bias=False, strides=(2, 2), padding='same', name='conv1/7x7_s2')(img_input) x = BatchNormalization(axis=bn_axis, name='conv1/7x7_s2/bn')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = senet_conv_block(x, 3, [64, 64, 256], stage=2, block=1, strides=(1, 1)) x = senet_identity_block(x, 3, [64, 64, 256], stage=2, block=2) x = senet_identity_block(x, 3, [64, 64, 256], stage=2, block=3) x = senet_conv_block(x, 3, [128, 128, 512], stage=3, block=1) x = senet_identity_block(x, 3, [128, 128, 512], stage=3, block=2) x = senet_identity_block(x, 3, [128, 128, 512], stage=3, block=3) x = senet_identity_block(x, 3, [128, 128, 512], stage=3, block=4) x = senet_conv_block(x, 3, [256, 256, 1024], stage=4, block=1) x = senet_identity_block(x, 3, [256, 256, 1024], stage=4, block=2) x = senet_identity_block(x, 3, [256, 256, 1024], stage=4, block=3) x = senet_identity_block(x, 3, [256, 256, 1024], stage=4, block=4) x = senet_identity_block(x, 3, [256, 256, 1024], stage=4, block=5) x = senet_identity_block(x, 3, [256, 256, 1024], stage=4, block=6) x = senet_conv_block(x, 3, [512, 512, 2048], stage=5, block=1) x = senet_identity_block(x, 3, [512, 512, 2048], stage=5, block=2) x = senet_identity_block(x, 3, [512, 512, 2048], stage=5, block=3) x = AveragePooling2D((7, 7), name='avg_pool')(x) if include_top: x = Flatten()(x) x = Dense(classes, activation='softmax', name='classifier')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='vggface_senet50') # load weights if weights == 'vggface': if include_top: weights_path = get_file('rcmalli_vggface_tf_senet50.h5', utils.SENET50_WEIGHTS_PATH, cache_subdir=utils.VGGFACE_DIR) else: weights_path = get_file('rcmalli_vggface_tf_notop_senet50.h5', utils.SENET50_WEIGHTS_PATH_NO_TOP, cache_subdir=utils.VGGFACE_DIR) model.load_weights(weights_path) if K.backend() == 'theano': layer_utils.convert_all_kernels_in_model(model) if include_top: maxpool = model.get_layer(name='avg_pool') shape = maxpool.output_shape[1:] dense = model.get_layer(name='classifier') layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first') if K.image_data_format() == 'channels_first' and K.backend() == 'tensorflow': warnings.warn('You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image data format convention ' '(`image_data_format="channels_first"`). ' 'For best performance, set ' '`image_data_format="channels_last"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') elif weights is not None: model.load_weights(weights) return model
def caltech_model2(n_classes: int, input_shape=None, input_tensor=None, weights_path: Union[None, str] = None) -> Sequential: """ Defines a caltech network. :param n_classes: the number of classes. We use this parameter even though we know its value, in order to be able to use the model in order to predict some of the classes. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained custom network's weights. :return: Keras Sequential Model. """ inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 5e-4 x = Conv2D(64, (3, 3), padding='same', activation='relu', input_shape=input_shape, kernel_regularizer=l2(weight_decay))(inputs) x = BatchNormalization()(x) x = Dropout(0.3)(x) x = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(128, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.4)(x) x = Conv2D(128, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(256, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.4)(x) x = Conv2D(256, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.4)(x) x = Conv2D(256, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(512, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.4)(x) x = Conv2D(512, (3, 3), padding='same', activation='relu', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.4)(x) x = Flatten()(x) x = Dense(512, kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) outputs = Dense(n_classes, activation='softmax', name='softmax_outputs')(x) # Create model. model = Model(inputs, outputs, name='caltech_model2') # Load weights, if they exist. load_weights(weights_path, model) return model
# 1 for grayscale num_channels = 1 # Number of classes, one class for each of 12 persons. num_classes = 12 model = Sequential() model.add(InputLayer(input_shape = (img_dim, img_dim))) model.add(Reshape(img_shape_full)) model.add(Conv2D(kernel_size = 5, strides = 1, filters = 16, padding = "same", activation = "relu", name = "conv_layer_1")) model.add(MaxPooling2D(pool_size = 2, strides = 2)) model.add(Conv2D(kernel_size = 5, strides = 1, filters = 36, padding = "same", activation = "relu", name = "conv_layer_2")) model.add(MaxPooling2D(pool_size = 2, strides = 2)) model.add(Conv2D(kernel_size = 5, strides = 1, filters = 56, padding = "same", activation = "relu", name = "conv_layer_3")) model.add(MaxPooling2D(pool_size = 2, strides = 2)) model.add(Conv2D(kernel_size = 5, strides = 1, filters = 80, padding = "same", activation = "relu", name = "conv_layer_4")) model.add(MaxPooling2D(pool_size = 2, strides = 2))
x_batch.append(process_wav_file(valid_df.wav_file.values[i])) y_batch.append(valid_df.label_id.values[i]) x_batch = np.array(x_batch) y_batch = to_categorical(y_batch, num_classes=len(POSSIBLE_LABELS)) yield x_batch, y_batch # In[16]: x_in = Input(shape=(257, 98, 2)) x = BatchNormalization()(x_in) for i in range(4): x = Conv2D(16 * (2**i), (3, 3))(x) x = Activation('elu')(x) x = BatchNormalization()(x) x = MaxPooling2D((2, 2))(x) x = Conv2D(128, (1, 1))(x) x_branch_1 = GlobalAveragePooling2D()(x) x_branch_2 = GlobalMaxPool2D()(x) x = concatenate([x_branch_1, x_branch_2]) x = Dense(256, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(len(POSSIBLE_LABELS), activation='sigmoid')(x) model = Model(inputs=x_in, outputs=x) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() # In[17]:
def build_unet(input_shape, num_classes): inputs = tf.keras.Input(shape=input_shape) conv1 = Conv2D(64, 3, activation='relu', dilation_rate=2, padding='same', kernel_initializer='he_normal')(inputs) conv1 = BatchNormalization()(conv1) conv1 = Conv2D(64, 3, activation='relu', dilation_rate=2, padding='same', kernel_initializer='he_normal')(conv1) conv1 = BatchNormalization()(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation='relu', dilation_rate=2, padding='same', kernel_initializer='he_normal')(pool1) conv2 = BatchNormalization()(conv2) conv2 = Conv2D(128, 3, activation='relu', dilation_rate=2, padding='same', kernel_initializer='he_normal')(conv2) conv2 = BatchNormalization()(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2) conv3 = BatchNormalization()(conv3) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3) conv3 = BatchNormalization()(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3) conv4 = BatchNormalization()(conv4) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4) conv4 = BatchNormalization()(conv4) drop4 = Dropout(0.5)(conv4, training=True) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4) conv5 = BatchNormalization()(conv5) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5) conv5 = BatchNormalization()(conv5) drop5 = Dropout(0.5)(conv5, training=True) up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(drop5)) merge6 = concatenate([drop4, up6], axis=3) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge6) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6) up7 = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv6)) merge7 = concatenate([conv3, up7], axis=3) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7) up8 = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv7)) merge8 = concatenate([conv2, up8], axis=3) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8) up9 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv8)) merge9 = concatenate([conv1, up9], axis=3) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9) conv9 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) x = Flatten()(conv9) x = Dense(512, activation='relu', kernel_initializer='he_uniform')(x) x = Dropout(0.3)(x) x = Dense(num_classes, activation='softmax', name='predictions')(x) return Model(inputs=inputs, outputs=x) return model
def UNet64_2x2core_large(input_shape): """wie UNet64_out_expansed, aber downsampling bis 2x2""" inputs = Input(shape=input_shape) conv01 = Conv2D(10, kernel_size=(3, 3), padding="same")(inputs) # 10 x 64x64 conv01 = Activation('relu')(conv01) conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32 print("0)", conv01_pool.shape, "10 x 32x32") conv02 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv01_pool) # 20 x 32x32 conv02 = Activation('relu')(conv02) conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16 print("1)", conv02_pool.shape, "20 x 16x16") conv03 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv02_pool) # 20 x 16x16 conv03 = Activation('relu')(conv03) conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8 print("2)", conv03_pool.shape, "20 x 8x8") conv04 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv03_pool) # 20 x 8x8 conv04 = Activation('relu')(conv04) conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4 print("3)", conv04_pool.shape, "20 x 4x4") conv05 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv04_pool) # 20 x 4x4 conv05 = Activation('relu')(conv05) conv05_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv05) # 20 x 2x2 print("4)", conv05_pool.shape, "20 x 2x2") ### UPSAMPLING: up05 = UpSampling2D((2, 2))(conv05_pool) # 20 x 4x4 up05 = concatenate([conv05, up05], axis=3) # 40 x 4x4 print("4)", up05.shape, "40 x 4x4") up04 = UpSampling2D((2, 2))(up05) # 10 x 8x8 up04 = concatenate([conv04, up04], axis=3) # 20+40 x 8x8 print("4)", up04.shape, "60 x 8x8") up03 = UpSampling2D((2, 2))(up04) # 30 x 16x16 up03 = concatenate([conv03, up03], axis=3) # 20+60 x 16x16 print("5)", up03.shape, "80 x 16x16") up02 = UpSampling2D((2, 2))(up03) # 80 x 32x32 up02 = concatenate([conv02, up02], axis=3) # 20+80 x 32x32 print("6)", up02.shape, "100 x 32x32") up01 = UpSampling2D((2, 2))(up02) # 100 x 64x64 up01 = concatenate([conv01, up01], axis=3) # 10+100 x 64x64 print("7)", up01.shape, "110 x 64x64") output = Conv2D(1, (3, 3), activation='relu', padding="same")(up01) # 1 x 64x64 print("8)", output.shape, "1 x 64x64") output = Flatten()(output) model = Model(inputs=inputs, outputs=output) model.compile(loss="mean_squared_error", optimizer='adam') return model
def ResNet50(input_shape=(64, 64, 3), classes=6): X_input = Input(input_shape) X = ZeroPadding2D((3, 3))(X_input) X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(axis=3, name='bn_conv1')(X) X = Activation('relu')(X) X = MaxPooling2D((3, 3), strides=(2, 2))(X) X = convolution_block(X, f=3, filters=[64, 64, 256], stage=2, block='a', s=1) X = identity_block(X, 3, [64, 64, 256], stage=2, block='b') X = identity_block(X, 3, [64, 64, 256], stage=2, block='c') X = convolution_block(X, f=3, filters=[128, 128, 512], stage=3, block='a', s=2) X = identity_block(X, 3, [128, 128, 512], stage=3, block='b') X = identity_block(X, 3, [128, 128, 512], stage=3, block='c') X = identity_block(X, 3, [128, 128, 512], stage=3, block='d') X = convolution_block(X, f=3, filters=[256, 256, 1024], stage=4, block='a', s=2) X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f') X = convolution_block(X, f=3, filters=[512, 512, 2048], stage=5, block='a', s=2) X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b') X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c') X = AveragePooling2D((2, 2), name='avg_pool')(X) X = Flatten()(X) X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer=glorot_uniform(seed=0))(X) model = Model(inputs=X_input, outputs=X, name='ResNet50') return model
def UNet64(input_shape, n_predictions=1, lossfunction="mean_squared_error", simpleclassification=None, flatten_output=True, optimizer="adam", activation_hidden="relu", activation_output="relu", metrics=None): inputs = Input(shape=input_shape) conv01 = Conv2D(10, kernel_size=(3, 3), padding="same")(inputs) # 10 x 64x64 conv01 = Activation(activation_hidden)(conv01) conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32 print("0)", conv01_pool.shape, "10 x 32x32") conv02 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv01_pool) # 20 x 32x32 conv02 = Activation(activation_hidden)(conv02) conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16 print("1)", conv02_pool.shape, "20 x 16x16") conv03 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv02_pool) # 20 x 16x16 conv03 = Activation(activation_hidden)(conv03) conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8 print("2)", conv03_pool.shape, "20 x 8x8") conv04 = Conv2D(20, kernel_size=(3, 3), padding="same")(conv03_pool) # 20 x 8x8 conv04 = Activation(activation_hidden)(conv04) conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4 print("3)", conv04_pool.shape, "20 x 4x4") ### UPSAMPLING: up04 = UpSampling2D((2, 2))(conv04_pool) # 20 x 8x8 up04 = concatenate([conv04, up04], axis=3) # 20+20 x 8x8 print("4)", up04.shape, "40 x 8x8") up03 = UpSampling2D((2, 2))(up04) # 40 x 16x16 up03 = concatenate([conv03, up03], axis=3) # 20+40 x 16x16 print("5)", up03.shape, "60 x 16x16") up02 = UpSampling2D((2, 2))(up03) # 60 x 32x32 up02 = concatenate([conv02, up02], axis=3) # 20+60 x 32x32 print("6)", up02.shape, "80 x 32x32") up01 = UpSampling2D((2, 2))(up02) # 80 x 64x64 up01 = concatenate([conv01, up01], axis=3) # 10+80 x 64x64 print("7)", up01.shape, "90 x 64x64") output = Conv2D(n_predictions, (1, 1), activation=activation_output)(up01) # 1 x 64x64 print("8)", output.shape, "{} x 64x64".format(n_predictions)) if flatten_output: output = Flatten()(output) print("output flattened to {}".format(output.shape)) if simpleclassification is not None: output = Dense(simpleclassification, activation='softmax')(output) print( "9)", output.shape, "zur Klassifikation von {} Klassen (mit softmax)".format( simpleclassification)) model = Model(inputs=inputs, outputs=output) if metrics is not None: model.compile(loss=lossfunction, optimizer=optimizer, metrics=metrics) else: model.compile(loss=lossfunction, optimizer=optimizer) return model
config = tf.compat.v1.ConfigProto(log_device_placement=True) config.gpu_options.allow_growth = True session = tf.compat.v1.Session(config=config) #running the model from tensorflow.python.client import device_lib print(device_lib.list_local_devices()) from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.layers import Conv2D, MaxPooling2D from tensorflow.python.keras.layers import Activation, Dropout, Flatten, Dense model = Sequential() model.add(Conv2D(32, kernel_size=2, input_shape=(450, 450, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, kernel_size=2)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, kernel_size=2)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation('sigmoid'))
def unet_network(input_tensor, nb_classes): """Original architecture of the network. Parameters ---------- input_tensor : Keras tensor, float32 Input tensor with shape (batch_size, ?, ?, 1). nb_classes : int Number of final classes. Returns ------- tensor : Keras tensor, float32 Output tensor with shape (batch_size, ?, ?, nb_classes) """ # contraction 1 conv1 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', name='conv1')(input_tensor) # (batch_size, ?, ?, 64) conv2 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', name='conv2')(conv1) # (batch_size, ?, ?, 64) crop2 = Cropping2D(cropping=((88, 88), (88, 88)), name="crop2")(conv2) # (batch_size, ?, ?, 64) maxpool2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name="maxpool2")(conv2) # (batch_size, ?, ?, 64) # contraction 2 conv3 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', name='conv3')(maxpool2) # (batch_size, ?, ?, 128) conv4 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', name='conv4')(conv3) # (batch_size, ?, ?, 128) crop4 = Cropping2D(cropping=((40, 40), (40, 40)), name="crop4")(conv4) # (batch_size, ?, ?, 128) maxpool4 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name="maxpool4")(conv4) # ((batch_size, ?, ?, 128) # contraction 3 conv5 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', name='conv5')(maxpool4) # (batch_size, ?, ?, 256) conv6 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', name='conv6')(conv5) # (batch_size, ?, ?, 256) crop6 = Cropping2D(cropping=((16, 16), (16, 16)), name="crop6")(conv6) # (batch_size, ?, ?, 256) maxpool6 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name="maxpool6")(conv6) # (batch_size, ?, ?, 256) # contraction 4 conv7 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu', name='conv7')(maxpool6) # (batch_size, ?, ?, 512) conv8 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu', name='conv8')(conv7) # (batch_size, ?, ?, 512) crop8 = Cropping2D(cropping=((4, 4), (4, 4)), name="crop8")(conv8) # (batch_size, ?, ?, 512) maxpool8 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name="maxpool8")(conv8) # (batch_size, ?, ?, 512) # bottom conv9 = Conv2D(filters=1024, kernel_size=(3, 3), activation='relu', name='conv9')(maxpool8) # (batch_size, ?, ?, 1024) conv10 = Conv2D(filters=1024, kernel_size=(3, 3), activation='relu', name='conv10')(conv9) # (batch_size, ?, ?, 1024) # expansion 1 upconv11 = up_conv_2d(input_tensor=conv10, nb_filters=512, name='upconv11') # (batch_size, ?, ?, 512) concat11 = tf.concat(values=[crop8, upconv11], axis=-1, name='concat11') # (batch_size, ?, ?, 1024) conv12 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu', name='conv12')(concat11) # (batch_size, ?, ?, 512) conv13 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu', name='conv13')(conv12) # (batch_size, ?, ?, 512) # expansion 2 upconv14 = up_conv_2d(input_tensor=conv13, nb_filters=256, name='upconv14') # (batch_size, ?, ?, 256) concat14 = tf.concat(values=[crop6, upconv14], axis=-1, name='concat14') # (batch_size, ?, ?, 512) conv15 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', name='conv15')(concat14) # (batch_size, ?, ?, 256) conv16 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', name='conv16')(conv15) # (batch_size, ?, ?, 256) # expansion 3 upconv17 = up_conv_2d(input_tensor=conv16, nb_filters=128, name='upconv17') # (batch_size, ?, ?, 128) concat17 = tf.concat(values=[crop4, upconv17], axis=-1, name='concat17') # (batch_size, ?, ?, 256) conv18 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', name='conv18')(concat17) # (batch_size, ?, ?, 128) conv19 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu', name='conv19')(conv18) # (batch_size, ?, ?, 128) # expansion 4 upconv20 = up_conv_2d(input_tensor=conv19, nb_filters=64, name='upconv20') # (batch_size, ?, ?, 64) concat20 = tf.concat(values=[crop2, upconv20], axis=-1, name='concat20') # (batch_size, ?, ?, 128) conv21 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', name='conv21')(concat20) # (batch_size, ?, ?, 64) conv22 = Conv2D(filters=64, kernel_size=(3, 3), activation='relu', name='conv22')(conv21) # (batch_size, ?, ?, 64) conv23 = Conv2D(filters=nb_classes, kernel_size=(1, 1), activation='sigmoid', name='conv23')(conv22) # (batch_size, ?, ?, nb_classes) return conv23
zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) entrenamiento_generador = entrenamiento_datagen.flow_from_directory(r"C:\Users\pasky\Documents\Master_en_Matematicas\PFM\Neuronal_Networks\Reference_code\AMP-Tech\CNN desde cero\data\entrenamiento", target_size=(altura, longitud), batch_size=batch_size, class_mode='categorical') validacion_generador = test_datagen.flow_from_directory( r"C:\Users\pasky\Documents\Master_en_Matematicas\PFM\Neuronal_Networks\Reference_code\AMP-Tech\CNN desde cero\data\validacion", target_size=(altura, longitud), batch_size=batch_size, class_mode='categorical') cnn = Sequential() cnn.add(Convolution2D(filtrosConv1, tamano_filtro1, padding ="same", input_shape=(longitud, altura, 3), activation='relu')) cnn.add(MaxPooling2D(pool_size=tamano_pool)) cnn.add(Convolution2D(filtrosConv2, tamano_filtro2, padding ="same")) cnn.add(MaxPooling2D(pool_size=tamano_pool)) cnn.add(Flatten()) cnn.add(Dense(256, activation='relu')) cnn.add(Dropout(0.5)) cnn.add(Dense(clases, activation='softmax')) cnn.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam(lr=lr), metrics=['accuracy'])
def build_vgg(img_rows: int = 224, img_cols: int = 224, num_classes: int = 1000): vgg = Sequential() vgg.add( Conv2D(64, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005), input_shape=(img_rows, img_cols, 3))) vgg.add( Conv2D(64, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005), input_shape=(img_rows, img_cols, 3))) vgg.add(MaxPooling2D()) # initial size /2 vgg.add( Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add(MaxPooling2D()) # initial size /4 vgg.add( Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add(MaxPooling2D()) # initial size /8 vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add(MaxPooling2D()) # initial size /16 vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add( Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', kernel_regularizer=l2(0.0005))) vgg.add(MaxPooling2D()) # initial size /32 vgg.add(Flatten()) vgg.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.0005))) vgg.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.0005))) vgg.add(Dropout(0.5)) vgg.add( Dense(num_classes, activation='softmax', kernel_regularizer=l2(0.0005))) return vgg