def model(lr): # get VGG16 base_model = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(32, 32, 3)) # freez Layers for layer in base_model.layers: layer.trainable = False # build New Network model = Sequential() model.add(base_model) model.add(GlobalAveragePooling2D()) model.add(BatchNormalization()) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dense(256, activation='relu')) model.add(Dropout(0.6)) model.add(Dense(10, activation='softmax')) # set optimizer model.compile(loss='categorical_crossentropy', optimizer=Adam(lr), metrics=['accuracy']) return model
def __init__(self, name): self.input_shape = (32, 32, 3) if name == "LeNet.h5": model = self.createLeNet() print("Built: LeNet") elif name == "ResNet56.h5": self.input_shape = (32, 32, 3) model = self.resnet_v2(self.input_shape, depth=56, num_classes=10) model.summary() print("Built: ResNet56") elif name == "VGG19.h5": model = vgg16.VGG16(include_top=False, weights=None, input_tensor=None, input_shape=self.input_shape, pooling=None, classes=1000) model.summary() print("Built: VGG19") elif name == "wrn.h5": init = (32, 32, 3) model = self.create_wide_residual_network(init, nb_classes=10, N=4, k=8, dropout=0.0) model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["acc"]) model.summary() print("Built: WRN") elif name == "custom.h5": model = self.createModel() print("Built: Custom") elif name == "AlexNet.h5": model = self.createAlexNet() print("Built: AlexNet") else: print("Build Failed") return model_path = os.path.join(save_dir, name) model.save(model_path)
def create_model(model="vgg19", pool="avg", padding="valid"): if model == "vgg19": default_model = vgg19.VGG19(weights="imagenet", include_top=False) elif model == "vgg16": default_model = vgg16.VGG16(weights="imagenet", include_top=False) new_layers = [] for i, layer in enumerate(default_model.layers): if i == 0: new_layers.append(keras.layers.Input((None, None, 3))) else: if isinstance(layer, keras.layers.Conv2D): config = layer.get_config() config["padding"] = padding new_layers.append(keras.layers.Conv2D.from_config(config)) elif isinstance(layer, keras.layers.MaxPooling2D): config = layer.get_config() config["padding"] = padding if pool == "avg": new_layers.append( keras.layers.AveragePooling2D.from_config(config)) else: new_layers.append( keras.layers.MaxPooling2D.from_config(config)) input = new_layers[0] output = input for i in range(1, len(new_layers)): output = new_layers[i](output) model = keras.models.Model(input, output) for new, old in zip(model.layers, default_model.layers): new.set_weights(old.get_weights()) return model
def search(files, db_path, mask_path, video_path, params): memory_graph = MemoryGraph(db_path, params) cnn = vgg16.VGG16(weights="imagenet", include_top=False, input_shape=(32, 32, 3)) orb = cv2.ORB_create(nfeatures=100000, fastThreshold=7) for file in files: search_file(file, memory_graph, cnn, orb, mask_path, video_path, params)
def un_activation_test(): vgg_model = vgg16.VGG16(weights='imagenet') vgg_model.summary() rand_data = np.random.randint(low=-10, high=10, size=(1, 112, 112, 128)) dlog.debug(rand_data) rand_data = un_activation(dget_layer(vgg_model, "block2_conv2"), rand_data) dlog.debug(rand_data)
def keras_fn(): ''' 对梯度值进行了修改,它是怎么做到不超出图片的数值范围的? :return: 更新后的输入值 ''' conv_base = vgg16.VGG16(include_top=False, weights='imagenet') im = Image.open('/Users/yongli/Pictures/flower.jpeg') im = im.resize((224, 224)) im_arr = np.array(im) im_arr = np.expand_dims(im_arr, axis=0) im_arr = im_arr.astype('float32') layer_name = 'block3_conv1' filter_idx = 0 layer_output = conv_base.get_layer(layer_name).output loss = K.mean(layer_output[:, :, :, filter_idx]) grads = K.gradients(loss, conv_base.input)[0] grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5) iterate = K.function([conv_base.input], [loss, grads]) step = 1 for i in range(40): loss_value, grads_value = iterate([im_arr]) im_arr += grads_value plot.imshow(im_arr[0]) plot.show()
def create_model(num_trainable_layers=None): vgg_conv = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) if num_trainable_layers is None: # Freeze all the layers for layer in vgg_conv.layers[:]: layer.trainable = False else: # Freeze all the layers for layer in vgg_conv.layers[:-num_trainable_layers]: layer.trainable = False # Create the model model = Sequential() model.add(vgg_conv) model.add(Flatten()) # model.add(Dense(512, activation='relu', input_dim=7 * 7 * 512)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(128, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(3, activation='softmax')) return model
def main(): parser = argparser() args = parser.parse_args() image_path = args.image layer_name = args.layer_name feature_to_visualize = args.feature visualize_mode = args.mode model = vgg16.VGG16(weights='imagenet', include_top=True) layer_dict = dict([(layer.name, layer) for layer in model.layers]) if not layer_dict.has_key(layer_name): print('Wrong layer name') sys.exit() # Load data and preprocess img = Image.open(image_path) img = img.resize((224, 224)) img_array = np.array(img) img_array = np.transpose(img_array, (2, 0, 1)) img_array = img_array[np.newaxis, :] img_array = img_array.astype(np.float) img_array = imagenet_utils.preprocess_input(img_array) deconv = visualize(model, img_array, layer_name, feature_to_visualize, visualize_mode) # postprocess and save image deconv = np.transpose(deconv, (1, 2, 0)) deconv = deconv - deconv.min() deconv *= 1.0 / (deconv.max() + 1e-8) deconv = deconv[:, :, ::-1] uint8_deconv = (deconv * 255).astype(np.uint8) img = Image.fromarray(uint8_deconv, 'RGB') img.save('results/{}_{}_{}.png'.format(layer_name, feature_to_visualize, visualize_mode))
def make_pred(self): class_labels = ["bread", "rice", "roti", "noodles", "kottu", "pizza"] # builds the model using the saved structure and weights f = Path("ds_comp/model_structure.json") model_structure = f.read_text() model = model_from_json(model_structure) model.load_weights("ds_comp/model_weights.h5") # converts the input image to a normalised numpy array img = image.load_img(self.file, target_size=(224, 224)) image_array = image.img_to_array(img) images = np.expand_dims(image_array, axis=0) images = vgg16.preprocess_input(images) # extracts the features of the new image feature_extraction = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) features = feature_extraction.predict(images) # Using the extracted features the model predicts what the image is results = model.predict(features) # prints the class label of the prediction using results produced single_result = results[0] most_likely_class_index = int(np.argmax(single_result)) class_label = class_labels[most_likely_class_index] print("{}".format(class_label)) return "{}".format(class_label)
def __init__(self): self.IMG_SIZE = 224 model_base = vgg16.VGG16(weights='imagenet', include_top=True, input_shape=(self.IMG_SIZE, self.IMG_SIZE, 3)) self.model = keras.Model(inputs=model_base.layers[0].input, outputs=model_base.layers[-2].output) self.model.summary()
def un_max_pooling_test(): A = np.random.randint(low=-10, high=10, size=(1, 4, 4, 4)) dlog.debug(A, flag=True, channels_first=True) R = get_switch(A, (2, 2)) vgg_model = vgg16.VGG16(weights='imagenet') data = max_pool(A, (2, 2)) output = un_max_pooling(vgg_model, 'block2_pool', data, R) dlog.debug(output, flag=True, channels_first=True)
def network(inputs): previous = vgg16.VGG16( include_top=False, input_tensor=inputs, pooling=pooling, weights=weights, ).output return tf.keras.layers.Flatten(name="flatten")(previous)
def __init__(self, settings: Settings, view_id, *args, **kwargs): super().__init__(*args, **kwargs) self.settings = settings self.view_id = view_id # region Use VGG16 if self.settings.svcnn_model == 'vgg16': vgg16_model = vgg16.VGG16(include_top=False, input_shape=settings.input_shape, pooling=None, weights=None) x = vgg16_model.layers[-1].output x = Flatten(name='flatten')(x) x = Dense(4096, activation='relu', name='fc1')(x) x = Dense(4096, activation='relu', name='fc2')(x) x = Dense(settings.num_classes, activation='softmax', name='predictions')(x) self.model_input = vgg16_model.input self.model_output = x self.model = Model(inputs=self.model_input, outputs=self.model_output) # endregion # region Use VGG19 elif self.settings.svcnn_model == 'vgg19': vgg19_model = vgg19.VGG19(include_top=False, input_shape=settings.input_shape, pooling=None, weights=None) x = vgg19_model.layers[-1].output x = Flatten(name='flatten')(x) x = Dense(4096, activation='relu', name='fc1')(x) x = Dense(4096, activation='relu', name='fc2')(x) x = Dense(settings.num_classes, activation='softmax', name='predictions')(x) self.model_input = vgg19_model.input self.model_output = x self.model = Model(inputs=self.model_input, outputs=self.model_output) # endregion # region Use ResNet50 elif self.settings.svcnn_model == 'resnet50': resnet50_model = resnet50.ResNet50( include_top=False, input_shape=settings.input_shape, pooling=None, weights=None) x = resnet50_model.layers[-1].output x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(settings.num_classes, activation='softmax', name='probs')(x) self.model_input = resnet50_model.input self.model_output = x self.model = Model(inputs=self.model_input, outputs=self.model_output)
def build(self): base_model = None output = None if self.include_top: if self.input_width_height != 224 or self.channels != 3: print( "IF include_top=True, input_shape MUST be (224,224,3), exiting..." ) exit() else: if self.name == "VGG" or self.name == "VGG16": base_model = vgg16.VGG16(weights=self.weights, include_top=True, classes=self.num_classes) else: print("Invalid name, accepted 'VGG1619', exiting...") exit() output = base_model.output else: inputs = Input(shape=(self.input_width_height, self.input_width_height, self.channels)) if self.name == "VGG" or self.name == "VGG16": base_model = vgg16.VGG16(weights=self.weights, include_top=False, input_tensor=inputs) else: print("Invalid name, accepted 'VGG16', exiting...") exit() flatten = Flatten(name='my_flatten') output_layer = Dense(self.num_classes, activation='softmax', name='my_predictions') output = output_layer(flatten(base_model.output)) input_layer = base_model.input model = Model(input_layer, output) # model.summary(line_length=50) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) return model
def get_vgg_activation(layer_name, width, height): tensor = K.placeholder((1, height, width, 3)) model = vgg16.VGG16(input_tensor=tensor, weights='imagenet', include_top=False) outputs_dict = {} for layer in model.layers: outputs_dict[layer.name] = layer.output layer.trainable = False return K.function([tensor], [outputs_dict[layer_name]])
def unet_resnet( input_shape=(256, 256, 3), num_classes=8, encoder_weights='imagenet'): base_model = resnet50.ResNet50(input_shape=input_shape, include_top=False, weights=encoder_weights) for l in base_model.layers: l.trainable = True conv0 = base_model.get_layer("activation").output conv1 = base_model.get_layer("activation_1").output conv2 = base_model.get_layer("activation_10").output conv3 = base_model.get_layer("activation_22").output conv4 = base_model.get_layer("activation_40").output conv5 = base_model.get_layer("activation_48").output # (None, 128, 128, 64) (None, 64, 64, 128) (None, 32, 32, 256) (None, 16, 16, 512) (None, 16, 16, 2048) # print(conv1.shape, conv2.shape, conv3.shape, conv4.shape, conv5.shape) up6 = K.concatenate([conv5, conv4], axis=-1) conv6 = conv_block_simple(up6, 256, "conv6_1") conv6 = conv_block_simple(conv6, 256, "conv6_2") up7 = K.concatenate([UpSampling2D()(conv6), conv3], axis=-1) conv7 = conv_block_simple(up7, 192, "conv7_1") conv7 = conv_block_simple(conv7, 192, "conv7_2") up8 = K.concatenate([UpSampling2D()(conv7), conv2], axis=-1) conv8 = conv_block_simple(up8, 128, "conv8_1") conv8 = conv_block_simple(conv8, 128, "conv8_2") up9 = K.concatenate([UpSampling2D()(conv8), conv1], axis=-1) conv9 = conv_block_simple(up9, 64, "conv9_1") conv9 = conv_block_simple(conv9, 64, "conv9_2") up9x = K.concatenate([UpSampling2D()(conv9), conv0], axis=-1) conv9x = conv_block_simple(up9x, 64, "conv9x_1") conv9x = conv_block_simple(conv9x, 64, "conv9x_2") vgg = vgg16.VGG16(input_shape=input_shape, input_tensor=base_model.input, include_top=False) for l in vgg.layers: l.trainable = False vgg_first_conv = vgg.get_layer("block1_conv2").output up10 = K.concatenate([UpSampling2D()(conv9x), vgg_first_conv], axis=-1) conv10 = conv_block_simple(up10, 32, "conv10_1") conv10 = conv_block_simple(conv10, 32, "conv10_2") conv10 = SpatialDropout2D(0.2)(conv10) x = Conv2D(num_classes, (1, 1), activation=None, name="prediction")(conv10) model = Model(base_model.input, x) return model
def __init__(self, style_layers = ['block1_conv2', 'block2_conv2', 'block3_conv3', 'block4_conv3']): super(LossNetwork, self).__init__() vgg = vgg16.VGG16(include_top=False, weights='imagenet') vgg.trainable = False model_outputs = [vgg.get_layer(name).output for name in style_layers] self.model = tf.keras.models.Model(vgg.input, model_outputs) # mixed precision float32 output self.linear = layers.Activation('linear', dtype='float32')
def UNet(nClasses, input_height, input_width): assert input_height % 32 == 0 assert input_width % 32 == 0 img_input = Input(shape=(input_height, input_width, 3)) vgg_streamlined = vgg16.VGG16(include_top=False, weights='imagenet', input_tensor=img_input) assert isinstance(vgg_streamlined, Model) o = UpSampling2D((2, 2))(vgg_streamlined.output) o = concatenate([vgg_streamlined.get_layer(name="block4_pool").output, o], axis=-1) o = Conv2D(512, (3, 3), padding="same")(o) o = BatchNormalization()(o) o = UpSampling2D((2, 2))(o) o = concatenate([vgg_streamlined.get_layer(name="block3_pool").output, o], axis=-1) o = Conv2D(256, (3, 3), padding="same")(o) o = BatchNormalization()(o) o = UpSampling2D((2, 2))(o) o = concatenate([vgg_streamlined.get_layer(name="block2_pool").output, o], axis=-1) o = Conv2D(128, (3, 3), padding="same")(o) o = BatchNormalization()(o) o = UpSampling2D((2, 2))(o) o = concatenate([vgg_streamlined.get_layer(name="block1_pool").output, o], axis=-1) o = Conv2D(64, (3, 3), padding="same")(o) o = BatchNormalization()(o) # UNet 네트워크 처리 입력이 2 배 미러링되므로 최종 입력 및 출력이 2 배 감소합니다. # 여기에서 직접 업 샘플링하고 원래 크기를 설정합니다. o = UpSampling2D((2, 2))(o) o = Conv2D(64, (3, 3), padding="same")(o) o = BatchNormalization()(o) o = Conv2D(1, (1, 1), padding="same")(o) o = BatchNormalization()(o) o = Activation("sigmoid")(o) # o = Conv2D(nClasses, (1, 1), padding="same")(o) # o = BatchNormalization()(o) # o = Activation("relu")(o) # o = Reshape((-1, nClasses))(o) # o = Activation("softmax")(o) model = Model(inputs=img_input, outputs=o) return model
def get_feature(x, layer_name): g_model = vgg16.VGG16(include_top=False, weights='imagenet') output1 = g_model.get_layer(layer_name).output fn = K.function([g_model.input], [output1]) print(x) # if x.shape != (224, 224, 3): x = np.reshape(x[0], (224, 224, 3)) output1_val = fn([x])[0] return output1_val
def getPerceptionModel(windowsize): model = vgg16.VGG16(weights="imagenet", include_top=False, input_shape=(windowsize, windowsize, 3)) model.trainable = False structureOutput = model.get_layer("block4_conv3").output perceptionModel = Model(inputs=model.inputs, outputs=structureOutput) perceptionModel.trainable = False for layer in perceptionModel.layers: layer.trainable = False return perceptionModel
def get_feature_val(layer_name, im): ''' 和全局变量比较,可能算是变量冗余吧 这里想要得到中间激活层的数据,就得使用K.function或者Model ''' vgg = vgg16.VGG16(include_top=False, weights='imagenet') output1 = vgg.get_layer(layer_name).output fn1 = K.function([vgg.input], [output1]) fn1_value = fn1([im])[0] fn1_value = fn1_value[0] print(fn1_value.shape) return fn1_value
def conv_filter_visualization_example(): # The name of the layer we want to visualize. # See model definition at keras/applications/vgg16.py. LAYER_NAME = 'block5_conv1' # Build the VGG16 network with ImageNet weights. vgg = vgg16.VGG16(weights='imagenet', include_top=False) print('Model loaded.') vgg.summary() # Visualize. visualize_layer(vgg, LAYER_NAME)
def perceptual_loss_wrapper(vgg_layer="block2_conv2"): vgg = vgg16.VGG16(include_top=False, weights="imagenet") perceptual_layer_model = Model(inputs=vgg.input, outputs=vgg.get_layer(vgg_layer).output) perceptual_layer_model.trainable = False perceptual_layer_model.compile(loss="mse", optimizer="adam") def perceptual_loss(y_true, y_pred): y_true_vgg = perceptual_layer_model(y_true) y_pred_vgg = perceptual_layer_model(y_pred) return tf.reduce_mean(tf.square(y_pred_vgg - y_true_vgg)) return perceptual_loss
def vgg16(input_shape, frozen_layers=0, weights=None, pooling='avg', **kwargs): # create the base model base_model = keras_vgg16.VGG16(weights=weights, include_top=False, input_shape=input_shape, pooling=pooling) predictions = add_classifier(base_model.output, **kwargs) model = models.Model(inputs=base_model.input, outputs=predictions) # Freeze some layers: freeze_layers(model, frozen_layers) return model
def VGG16_Feature(img_shape=(256, 256, 3)): vgg16_model = vgg16.VGG16(include_top=False, weights='imagenet', input_shape=img_shape) model = Model( inputs=[vgg16_model.input], outputs=[ vgg16_model.layers[1].output, vgg16_model.layers[2].output, vgg16_model.layers[4].output, vgg16_model.layers[5].output, vgg16_model.layers[7].output, vgg16_model.layers[8].output, vgg16_model.layers[9].output ]) model.trainable = False return model
def transfer_learning(): vgg_conv = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, CHANNELS)) for layer in vgg_conv.layers[:]: layer.trainable = False model = Sequential() model.add(vgg_conv) model.add(Flatten()) model.add(Dense(1024, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(2, activation='softmax')) model.summary() return model
def un_filter_test(): vgg_model = vgg16.VGG16(weights='imagenet') inter_model = dget_intermediate_model(vgg_model, 'block3_conv3') # load test image img = load_img(TEST_IMAGE_PATH, target_size=(224, 224)) numpy_image = img_to_array(img) image_batch = np.expand_dims(numpy_image, axis=0) # prepare the image for the VGG model processed_image = vgg16.preprocess_input(image_batch) pred = inter_model.predict(processed_image) pred = np.squeeze(pred) output = un_filter(pred, inter_model, 'block3_conv3') dlog.debug(output)
def get_prediction_class(filename): """ Gets the prediction class from VGG16 pretrained model Input Args: filename = absolute path of an image Output: output_class """ model_file_path = "saved_models/vgg16_weights_tf_dim_ordering_tf_kernels.h5" if not os.path.exists(model_file_path): print('downloading the vgg model') download_vgg16(model_file_path) print('download of vgg model finished') vgg_model = vgg16.VGG16(weights=model_file_path) # load an image in PIL format original = load_img(filename, target_size=(224, 224)) # convert the PIL image to a numpy array # IN PIL - image is in (width, height, channel) # In Numpy - image is in (height, width, channel) numpy_image = img_to_array(original) # Convert the image / images into batch format # expand_dims will add an extra dimension to the data at a particular axis # We want the input matrix to the network to be of the form (batchsize, height, width, channels) # Thus we add the extra dimension to the axis 0. image_batch = np.expand_dims(numpy_image, axis=0) # prepare the image for the VGG model processed_image = vgg16.preprocess_input(image_batch.copy()) # get the predicted probabilities for each class predictions = vgg_model.predict(processed_image) # print predictions # convert the probabilities to class labels # we will get top 5 predictions which is the default label_vgg = decode_predictions(predictions) # print VGG16 predictions output_class = label_vgg[0][0][1] return output_class
def UNet(nClasses, input_height, input_width): assert input_height % 32 == 0 assert input_width % 32 == 0 img_input = layers.Input(shape=(input_height, input_width, 3)) base = vgg16.VGG16(include_top=False, weights='imagenet', input_tensor=img_input) base_out = base.output b4 = base.get_layer(name="block4_pool").output b3 = base.get_layer(name="block3_pool").output b2 = base.get_layer(name="block2_pool").output b1 = base.get_layer(name="block1_pool").output x = layers.UpSampling2D((2, 2))(base_out) x = layers.concatenate([b4, x], axis=-1) x = layers.Conv2D(512, (3, 3), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.UpSampling2D((2, 2))(x) x = layers.concatenate([b3, x], axis=-1) x = layers.Conv2D(256, (3, 3), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.UpSampling2D((2, 2))(x) x = layers.concatenate([b2, x], axis=-1) x = layers.Conv2D(128, (3, 3), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.UpSampling2D((2, 2))(x) x = layers.concatenate([b1, x], axis=-1) x = layers.Conv2D(64, (3, 3), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.UpSampling2D((2, 2))(x) x = layers.Conv2D(64, (3, 3), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Conv2D(nClasses, (1, 1), padding="same")(x) x = layers.BatchNormalization()(x) x = layers.Activation("relu")(x) x = layers.Reshape((-1, nClasses))(x) x = layers.Activation("softmax")(x) return Model(inputs=img_input, outputs=x)
def get_grad(gImArr): """ Calculate the gradient of the loss function with respect to the generated image K.gradient """ g_model = vgg16.VGG16(include_top=False, weights='imagenet') target_width = 224 target_height = 224 if gImArr.shape != (1, target_width, target_height, 3): gImArr = gImArr.reshape((1, target_width, target_height, 3)) grad_fcn1 = K.gradients(get_loss([g_model.input]), g_model.input)[0] grad_fcn = K.function([g_model.input], grad_fcn1) print(type(grad_fcn)) grad = grad_fcn([gImArr])[0].flatten().astype('float64') return grad