def create_uncertainty_model(learning_rate=1e-3, num_hidden_units=20, type = 'mobilenet_v2'): mu_input = Input(shape=(num_classes,)) if type == 'mobilenet_v2': base_model = mobilenet_v2.MobileNetV2(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) elif type == 'vgg16': base_model = vgg16.VGG16(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) elif type == 'resnet50': base_model = resnet50.ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) elif type == 'vgg19': base_model = vgg19.VGG19(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) elif type == 'inception_v3': base_model = inception_v3.InceptionV3(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) else: base_model = mobilenet_v2.MobileNetV2(include_top=False, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling='avg', classes=num_classes) base_model.trainable = False beta = base_model.output beta = Dense(num_hidden_units, activation='relu')(beta) beta = Dense(num_hidden_units, activation='relu')(beta) beta = Dense(num_hidden_units, activation='relu')(beta) # beta = Dense(num_hidden_units,activation='relu')(beta) beta = Dense(1, activation='sigmoid')(beta) output = concatenate([mu_input, beta]) model = Model(inputs=[mu_input, base_model.input], outputs=output) model.compile(loss=dirichlet_aleatoric_cross_entropy, optimizer=Adam(lr=learning_rate), metrics=[max_beta, min_beta] ) return model
def __init__(self, cls_num, input_size): super().__init__() self.model_state = "Reference" # self.ref_model = Sequential(name="reference") # self.tar_model = Sequential(name="secondary") # # self.build_network(cls_num, input_size) self.vgg_model = vgg16.VGG16(weights="imagenet") # self.ref_model = self.get_dropout_model( self.vgg_model, 2) # self.tar_model = self.get_dropout_model(self.vgg_model, 1) self.ref_model = self.vgg_model self.tar_model = self.vgg_model self.features_net = self.get_features_network(self.vgg_model) for layer in self.vgg_model.layers[:19]: layer.trainable = False self.ref_model.summary() self.tar_model.summary() self.features_net.summary() self.ready_for_train = False self.trainer = None self.validator = None
def cover(): global root2, frame2, time root2 = tk.Toplevel() root2.title('Portable Image Classifier') root2.resizable(False, False) tit = tk.Label(root2, text="Age Cover Gender Classification", padx=25, pady=6, font=("", 12)).pack() canvas = tk.Canvas(root2, height=500, width=500, bg='grey') canvas.pack() frame2 = tk.Frame(root2, bg='white') for img_display in frame2.winfo_children(): img_display.destroy() image_data = r"C:\Users\User\Desktop\evaluation\cover.jpg" basewidth = 370 # Processing image for dysplaying img = Image.open("cover.jpg") wpercent = (basewidth / float(img.size[0])) hsize = int((float(img.size[1]) * float(wpercent))) img = img.resize((basewidth, hsize), Image.ANTIALIAS) img = ImageTk.PhotoImage(img) file_name = image_data.split('/') panel = tk.Label(frame2, text=str(' ').upper()).pack() panel_image = tk.Label(frame2, image=img).pack() frame2.place(relwidth=0.8, relheight=0.8, relx=0.1, rely=0.1) chose_image = tk.Button(root2, text='Low Light Image', padx=45, pady=10, fg="white", bg="grey", command=low) chose_image.pack(side=tk.LEFT) enhance_image = tk.Button(root2, text='Blurred Image', padx=35, pady=10, fg="white", bg="grey", command=blur) enhance_image.pack(side=tk.LEFT) class_image = tk.Button(root2, text='Pixelated Image', padx=35, pady=10, fg="white", bg="grey", command=pixelate) class_image.pack(side=tk.RIGHT) vgg_model = vgg16.VGG16(weights='imagenet') if (time == 'second'): root.destroy() root2.mainloop()
def loadModel(self): vgg16Model = vgg16.VGG16(include_top = False, weights = 'imagenet', input_shape = imageDataList[0].shape) model = Sequential() for layer in vgg16Model.layers: model.add(layer) model.add(Flatten(name='flatten')) model.add(Dense(1000, activation='relu')) model.add(Dense(1, activation = 'sigmoid')) model.load_weights(self.weightFilePath)
def main(): global frame, img, root root = tk.Toplevel() root.title('Portable Image Classifier') root.resizable(False, False) tit = tk.Label(root, text="Age defult Gender Classification", padx=25, pady=6, font=("", 12)).pack() canvas = tk.Canvas(root, height=550, width=550, bg='grey') canvas.pack() frame = tk.Frame(root, bg='white') frame.place(relwidth=0.8, relheight=0.8, relx=0.1, rely=0.1) chose_image = tk.Button(root, text='Load Image', padx=45, pady=10, fg="white", bg="grey", command=load_img) chose_image.pack(side=tk.LEFT) enhance_image = tk.Button(root, text='Enhance Image', padx=35, pady=10, fg="white", bg="grey", command=enhance_img) enhance_image.pack(side=tk.LEFT) goback = tk.Button(root, text='Back', padx=35, pady=10, fg="white", bg="grey", command=back) goback.pack(side=tk.RIGHT) class_image = tk.Button(root, text='Classify Image', padx=35, pady=10, fg="white", bg="grey", command=classify) class_image.pack(side=tk.LEFT) vgg_model = vgg16.VGG16(weights='imagenet') root2.destroy() root.mainloop()
def __init__(self): super().__init__() self.model = vgg16.VGG16(weights='imagenet') self.is_compiled = False self.loss = None self.optimizer = None self.train_loss_tracker = tf.keras.metrics.Mean(name="train_loss") self.val_loss_tracker = tf.keras.metrics.Mean(name="train_loss") self.train_accuracy_tracker = tf.keras.metrics.CategoricalAccuracy() self.val_accuracy_tracker = tf.keras.metrics.CategoricalAccuracy()
def getModel(self, input_shape, classes=1): vgg16_model = vgg16.VGG16(include_top = False, weights = 'imagenet', input_shape = input_shape) model = Sequential() for layer in vgg16_model.layers: model.add(layer) for layer in model.layers: layer.trainable = False model.add(Flatten(name='flatten')) model.add(Dense(1000, activation='relu')) model.add(Dense(classes, activation = 'sigmoid')) return model
def init(): global model global model_extractfeatures global graph global collection model = vgg16.VGG16(weights='imagenet', include_top=True) model_extractfeatures = Model(model.input, outputs=model.get_layer('fc2').output) graph = tf.get_default_graph() global fin_centroids fin_centroids = Results.centroid_to_dict( Results.read_centroids("data/centroids.pkl")) client = MongoClient() db = client.flickrurls collection = db["final_data"]
def __init__(self): super().__init__() # self.__model = vgg16.VGG16(weights='imagenet', include_top=False) vgg_conv = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) for layer in vgg_conv.layers[:]: layer.trainable = False self.__model = tf.keras.Sequential() self.__model.add(vgg_conv) self.__model.add(tf.keras.layers.Flatten()) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add(tf.keras.layers.Dropout(0.5)) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add(tf.keras.layers.Dropout(0.5)) self.__model.add(tf.keras.layers.Dense(76, activation='softmax')) self.__model.summary()
def get_loss_net(pastiche_net_output, input_tensor=None): ''' Instantiates a VGG net and applies its layers on top of the pastiche net's output. ''' loss_net = vgg16.VGG16(weights='imagenet', include_top=False, input_tensor=input_tensor) targets_dict = dict([(layer.name, layer.output) for layer in loss_net.layers]) i = pastiche_net_output # We need to apply all layers to the output of the style net outputs_dict = {} for l in loss_net.layers[1:]: # Ignore the input layer i = l(i) outputs_dict[l.name] = i return loss_net, outputs_dict, targets_dict
def FCN32(nClasses, input_height, input_width): img_input = Input(shape=(input_height, input_width, 3)) model = vgg16.VGG16(include_top=False, weights='imagenet', input_tensor=img_input) # vgg去除全连接层为:7x7x512 # vgg:5个block,1:filters:64,kernel:3;3-128;3-256;3-512 o = Conv2D(filters=1024, kernel_size=(7, 7), padding='same', activation='relu', name='fc6')(model.output) o = Dropout(0.5)(o) o = Conv2D(filters=1024, kernel_size=(1, 1), padding='same', activation='relu', name='fc7')(o) o = Dropout(0.5)(o) o = Conv2D(filters=nClasses, kernel_size=(1, 1), padding='same', activation='relu', name='score_fr')(o) o = Conv2DTranspose(filters=nClasses, kernel_size=(32, 32), strides=(32, 32), padding='valid', activation=None, name='score2')(o) o = Reshape((-1, nClasses))(o) o = Activation("softmax")(o) fcn8 = Model(img_input, o) return fcn8
def __init__(self, classes_num, input_size): super().__init__(classes_num, input_size) self.output_path = None vgg_conv = vgg16.VGG16(weights=None, include_top=False, classes=classes_num, input_shape=(input_size[0], input_size[0], 3)) vgg_conv.summary() # for layer in vgg_conv.layers[:]: # layer.trainable = False self.__model = tf.keras.Sequential() self.__model.add(vgg_conv) self.__model.add(tf.keras.layers.Flatten()) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add(tf.keras.layers.Dropout(0.5)) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add(tf.keras.layers.Dropout(0.5)) self.__model.add( tf.keras.layers.Dense(classes_num, activation='softmax')) self.__model.summary()
def __init__(self, classes_num, input_size): super().__init__(classes_num, input_size) self.output_path = None vgg_conv = vgg16.VGG16(weights=None, include_top=False, input_shape=(input_size[0], input_size[0], 3)) vgg_conv.summary() # for layer in vgg_conv.layers[:]: # layer.trainable = False self.__model = tf.keras.Sequential() self.__model.add(vgg_conv) self.__model.add(tf.keras.layers.Flatten()) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add(tf.keras.layers.Dense(4096, activation='relu')) self.__model.add( tf.keras.layers.Dense(classes_num, activation='softmax')) self.__model.summary() if os.path.exists(self.get_last_ckpt_path()): self.load_model(self.get_last_ckpt_path()) print("loads last weights")
def __init__(self): super().__init__() self.__model = vgg16.VGG16(weights='imagenet') self.__model.summary()
default=None, nargs='+', help='Style image file names.') parser.add_argument('--style_img_size', type=int, default=[None], nargs='+', help='Largest size of the style images') parser.add_argument('--style_layers', type=str, nargs='+', default=def_sl) parser.add_argument('--gpu', type=str, default='') parser.add_argument('--allow_growth', default=False, action='store_true') args = parser.parse_args() config_gpu(args.gpu, args.allow_growth) loss_net = vgg16.VGG16(weights='imagenet', include_top=False) targets_dict = dict([(layer.name, layer.output) for layer in loss_net.layers]) s_targets = get_style_features(targets_dict, args.style_layers) get_style_target = K.function([loss_net.input], s_targets) gm_lists = [[] for l in args.style_layers] img_list = [] img_size_list = [] # Get style image names or get all images in the directory if args.style_imgs is None: args.style_imgs = os.listdir(args.style_dir)
from tensorflow.python.keras.applications import vgg16 weights_path = r"F:\5-model data\vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5" model = vgg16.VGG16(weights=weights_path, include_top=False) model.summary() #设置DeepDream配置 layer_contributions = { 'mixed2': 0.2, 'mixed3': 3., 'mixed4': 2., 'mixed5': 1.5, }
content_image = K.zeros(shape=shape) images = K.concatenate([style_image, target_image, content_image], axis=0) # Create tensor variables for masks raw_style_mask, raw_target_mask = load_mask_labels() style_mask = K.variable(raw_style_mask.astype("float32")) target_mask = K.variable(raw_target_mask.astype("float32")) masks = K.concatenate([style_mask, target_mask], axis=0) # index constants for images and tasks variables STYLE, TARGET, CONTENT = 0, 1, 2 # Build image model, mask model and use layer outputs as features # image model as VGG19 image_model = vgg16.VGG16(include_top=False, input_tensor=images) # mask model as a series of pooling mask_input = Input(tensor=masks, shape=(None, None, None), name="mask_input") x = mask_input for layer in image_model.layers[1:]: name = 'mask_%s' % layer.name if 'conv' in layer.name: x = AveragePooling2D((3, 3), strides=(1, 1), name=name, border_mode="same")(x) elif 'pool' in layer.name: x = AveragePooling2D((2, 2), name=name)(x) mask_model = Model(mask_input, x)
from tensorflow.python.keras.preprocessing import image from tensorflow.python.keras.applications.vgg16 import preprocess_input from tensorflow.python.keras.models import Model import numpy as np import matplotlib.pyplot as plt import pprint import pandas as pd import pickle import time import subprocess # pp = pprint.PrettyPrinter(indent=2) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' model = vgg16.VGG16(weights='imagenet', include_top=True) model_extractfeatures = Model(model.input, outputs=model.get_layer('fc2').output) def read_centroids(path): f = open(path, "rb") centroids = pickle.load(f) f.close() return centroids def to_float_arr(arr): return np.array(list(map(float, arr)))
def load_trained_model(): vgg_model = vgg16.VGG16(weights='imagenet') feature_extractor = Model(inputs=vgg_model.input, outputs=vgg_model.get_layer('fc2').output) feature_extractor.summary() return feature_extractor
import cv2 import numpy as np from tensorflow.python.keras.applications import vgg16 from tensorflow.python.keras.layers import Dense from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.optimizers import Adam from tensorflow.python.keras.preprocessing.image import ImageDataGenerator vgg16_model = vgg16.VGG16() # vgg16 modelini getirdik #Train ,test , valid klasörleri altında Dog ve Cat adında klasörler oluşturup buraya fotoğrafları ayrı ayrı atın train_path = 'C:\\Users\\bagat\\OneDrive\\Masaüstü\\DCimages\\Train' valid_path = 'C:\\Users\\bagat\\OneDrive\\Masaüstü\\DCimages\\Valid' test_path = 'C:\\Users\\bagat\\OneDrive\\Masaüstü\\DCimages\\Test' # verdiğimiz yoldan batch halinde resimleri alır train_batches = ImageDataGenerator().flow_from_directory( train_path, target_size=(224, 224), classes=['Cat', 'Dog'], batch_size=10) test_batches = ImageDataGenerator().flow_from_directory(test_path, target_size=(224, 224), classes=['Cat', 'Dog'], batch_size=10) valid_batches = ImageDataGenerator().flow_from_directory( valid_path, target_size=(224, 224), classes=['Cat', 'Dog'], batch_size=4) imgs, labels = next(train_batches) model = Sequential() # modelin sonra katmanında 1000 tane sınıf var bunun yerine biz 2 sınıf istiyoruz son katmanı silip modei aldık for layer in vgg16_model.layers[:-1]: model.add(layer) # vgg16 modelini kendi modelimize aktardık
# ref_val_datagen = ref_gen.flow_from_directory(ref_path, subset="validation", # class_mode="categorical", # target_size=input_size, # batch_size=batch_size, classes=ref_classes) ref_train_datagen, ref_val_datagen = get_iterators_by_root_dir(ref_path, batch_size, input_size, 0.2, 1000, shuffle=True) # ref_train_datagen = get_iterator("C:/Users/lotan/Documents/studies/Affordances/datasets/imagenet_files/train.txt") # ref_val_datagen = get_iterator("C:/Users/lotan/Documents/studies/Affordances/datasets/imagenet_files/val.txt") model = vgg16.VGG16(weights="imagenet") loss_fn = tf.keras.losses.CategoricalCrossentropy() accuracy_func_train = tf.keras.metrics.CategoricalAccuracy() loss_tracker_train = tf.keras.metrics.Mean(name="loss") accuracy_func_val = tf.keras.metrics.CategoricalAccuracy() loss_tracker_val = tf.keras.metrics.Mean(name="loss") for layer in model.layers[:19]: layer.trainable = False print(layer.name) model.summary() base_learning_rate = 0.00001 optimizer = tf.keras.optimizers.Adam(lr=base_learning_rate)
def get_vgg16_model(weights='imagenet', input_tensor=None): return vgg16.VGG16(weights=weights, include_top=False, input_tensor=input_tensor)
def __init__(self): super().__init__() self.__model = vgg16.VGG16(weights='imagenet') self.ref_model = self.get_dropout_model(0) self.tar_model = self.get_dropout_model(0) print(self.tar_model.summary())