def get_model(pooling='avg', input_shape=None): base_model = ResNet50(weights='imagenet', include_top=False, pooling=pooling, input_shape=input_shape) return base_model, preprocess_input
def __init__(self, input_data_shape, num_classes, model_name='resnet50', trainable_layers_amount=1): super(ImageModel, self).__init__() self.num_classes = num_classes self.model_name = model_name self.trainable_layers_amount = trainable_layers_amount self.input_data_shape = input_data_shape if self.model_name == 'resnet50': self.base_model = ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=self.input_data_shape) # Avoid training layers in resnet model. layers = self.base_model.layers print("Layers name") for layer in layers: print(layer.name) layer.trainable = False print("Making layers trainable") for layer in layers[-trainable_layers_amount:]: print(layer.name) layer.trainable = True x0 = Input(shape=self.input_data_shape) x1 = Lambda(preprocess_input, output_shape=self.input_data_shape)(x0) x2 = self.base_model(x1) x3 = GlobalAveragePooling2D()(x2) x4 = Dense(1024, activation='relu')(x3) x5 = Dense(num_classes, activation='softmax', name='softmax')(x4) self.model = Model(inputs=x0, outputs=x5)
def create_model(): dropout = 0.5 reg = l2(0.01) opt = Adam(lr=LEARN_RATE) conv_base = ResNet50(weights='imagenet', include_top=False, input_shape=INPUT_SHAPE) conv_base.trainable = False model = models.Sequential() model.add(conv_base) model.add(AveragePooling2D(pool_size=(2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(dropout)) model.add( layers.Dense(512, activation='relu', kernel_initializer='uniform', kernel_regularizer=reg)) model.add(layers.Dropout(dropout)) model.add( layers.Dense(512, activation='relu', kernel_initializer='uniform', kernel_regularizer=reg)) model.add(layers.Dropout(dropout)) model.add(layers.Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy']) model.summary() # tf.keras.utils.plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True) return model
def create_model(): conv_base = ResNet50(weights='imagenet', include_top=False, input_shape=INPUT_SHAPE) conv_base.trainable = False model = models.Sequential() model.add(conv_base) model.add(layers.GlobalAveragePooling2D()) model.add( layers.Dense(512, activation='relu', kernel_initializer='uniform', kernel_regularizer=reg)) model.add(layers.Dropout(0.5)) model.add( layers.Dense(512, activation='relu', kernel_initializer='uniform', kernel_regularizer=reg)) model.add(layers.Dropout(0.5)) model.add( layers.Dense(2, activation='softmax', kernel_initializer='uniform', kernel_regularizer=reg)) model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=LEARN_RATE, momentum=0.9), metrics=['accuracy']) model.summary() return model
def __init__(self, x, t, LR, input_shape, output_shape, model_name='FCN_ResNet50'): # optimization setting self.LR = LR # naming setting self.model_name = model_name # pretrain model self.resnet50 = ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=input_shape[1:]) self.resnet50.trainable = False #for layer in resnet50.layers[:164]: # layer.trainable = False # model setting self.input_shape = input_shape self.output_shape = output_shape with tf.variable_scope(self.model_name): self.x = x self.t = t self.features = self.resnet50(inputs=self.x) # (3, 14, 2048) self.y = self._forward_pass(self.features)
def __generate_pretrained_encoder(input_layer: Model): resnet = ResNet50(include_top=False, weights='imagenet', input_tensor=input_layer, input_shape=(512, 512, 3), pooling=None) return resnet
def __init__(self, input_sizeW, input_sizeH): resnet50 = ResNet50(input_shape=(input_sizeW, input_sizeH, 3), include_top=False) resnet50.layers.pop() # remove the average pooling layer #resnet50.load_weights(RESNET50_BACKEND_PATH) self.feature_extractor = Model(resnet50.layers[0].input, resnet50.layers[-1].output)
def initResNet50(): print('Loading ResNet50 model...') if not os.path.isfile('resnet50.h5'): urllib.urlretrieve(RESNET50_URL, filename='resnet50.h5') print('ResNet50 model downloaded') model = ResNet50(weights='resnet50.h5') print('ResNet50 model loaded from disk') return model
def main(): (x_train, y_train), (x_test, y_test) = cifar10.load_data() y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = ResNet50(input_shape=(32, 32, 3), include_top=False, weights='imagenet', classes=10) model.summary()
def get_model(): # define ResNet50 model model = ResNet50(weights='imagenet') # get AMP layer weights amp_weights = model.layers[-1].get_weights()[0] # extract wanted output model = Model(inputs=model.input, outputs=(model.layers[-4].output, model.layers[-1].output)) return model, amp_weights
def get_model(input_shape=(128, 128, 16), classes=4, activation='sigmoid'): resnet = ResNet50(weights=None, include_top=False, input_shape=input_shape) model = Sequential() model.add(resnet) model.add(GlobalAveragePooling2D()) model.add( Dense(units=classes, activation=activation, kernel_initializer="he_normal")) return model
def evaluate(encoder, decoder, optimizer, step_counter, image): attention_plot = np.zeros((max_length, attention_features_shape)) hidden = decoder.reset_state(batch_size=1) size = [224, 224] def load_image(image_path): img = tf.read_file(PATH + image_path) img = tf.image.decode_jpeg(img, channels=3) img = tf.image.resize(img, size) img = tf.keras.applications.resnet50.preprocess_input(img) return img, image_path from tensorflow.python.keras.applications.resnet50 import ResNet50 image_model = ResNet50( weights='resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', include_top=False) #创建ResNet网络 new_input = image_model.input hidden_layer = image_model.layers[-2].output image_features_extract_model = tf.keras.Model(new_input, hidden_layer) temp_input = tf.expand_dims(load_image(image)[0], 0) img_tensor_val = image_features_extract_model(temp_input) img_tensor_val = tf.reshape( img_tensor_val, (img_tensor_val.shape[0], -1, img_tensor_val.shape[3])) features = encoder(img_tensor_val) # print(step_counter.numpy()) dec_input = tf.expand_dims([tokenizer.word_index['<start>']], 0) result = [] for i in range(max_length): predictions, hidden, attention_weights = decoder( dec_input, features, hidden) attention_plot[i] = tf.reshape(attention_weights, (-1, )).numpy() print(predictions.get_shape()) predicted_id = tf.multinomial(predictions, num_samples=1)[0][0].numpy() result.append(index_word[predicted_id]) print(predicted_id) if index_word[predicted_id] == '<end>': return result, attention_plot dec_input = tf.expand_dims([predicted_id], 0) attention_plot = attention_plot[:len(result), :] return result, attention_plot
def create_model(): model = ResNet50(include_top=False, weights='imagenet', pooling='max') inp = Input(input_shape, name='input_image') out = model(inp) out = Flatten()(out) out = Dense(1024)(out) out = Dropout(0.75)(out) out = Dense(1)(out) model = Model(inputs=[inp], outputs=out) model.compile(optimizer=Adam(lr=0.001), loss='binary_crossentropy') return model
def resnet_model(): model = ResNet50(weights=None, include_top=True, input_shape=(75, 75, 3), classes=196) model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(lr=2e-5), metrics=['acc']) return model
def buildModel(num_classes): model = Sequential() model.add(ResNet50(include_top=False, pooling='avg', weights='imagenet')) model.add(Dense(num_classes, activation='softmax')) # Say not to train first layer (ResNet) model. It is already trained model.layers[0].trainable = False model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) return model
def init_model(model_name): if (model_name == "VGG19"): # Initialisierung des VGG19 return VGG19(include_top=True, weights='imagenet') if (model_name == "VGG16"): return tf.keras.applications.VGG16(include_top=True, weights='imagenet') if (model_name == "ResNet50"): return ResNet50(include_top=True, weights="imagenet") if (model_name == "DenseNet201"): return DenseNet201(include_top=True, weights="imagenet") if (model_name == "DenseNet121"): return DenseNet121(include_top=True, weights="imagenet") if (model_name == "InceptionResNetV2"): return InceptionResNetV2(include_top=True, weights="imagenet")
def build(self): resnet50_model = ResNet50(include_top=False, weights='imagenet', input_shape=(32, 256, 3)) x = resnet50_model.output conv_outputs = Lambda(self.squeeze_wrapper)(x) logger.debug("Resnet50输出的feature map shape:%r", conv_outputs.get_shape().as_list()) inputs = resnet50_model.inputs # inputs=[(-1,32,256,3)] # conv_outputs=[-1,8,2048] return conv_outputs, inputs[0]
def make_numpy_feature(numpyPATH, img_filename, PATH, weights=RESNET50_WEIGHTS): ''' 将图片转化为特征数据 :param numpyPATH:存储提取好特征后的存储文件夹 :param img_filename:图片文件列表 :param PATH: 图片所在的文件夹 :param weights: ResNet50模型的权重 :return: ''' if os.path.exists(numpyPATH): # 去除已有文件夹 shutil.rmtree(numpyPATH, ignore_errors=True) os.mkdir(numpyPATH) # 新建文件夹 size = [224, 224] # 设置输出尺寸 batch_size = 10 # 批量大小 def load_image(image_path): '''输入图片的预处理''' img = tf.compat.v1.read_file(PATH + image_path) img = tf.image.decode_jpeg(img, channels=3) img = tf.image.resize(img, size) # 使用Reset模型的统一预处理 img = tf.keras.applications.resnet50.preprocess_input(img) return img, image_path # 创建ResNet模型 image_model = ResNet50(weights=weights, include_top=False) new_input = image_model.input # 获取ResNet导数第二层(池化前的卷积结果) hidden_layer = image_model.layers[-2].output image_feature_extract_model = tf.keras.Model(new_input, hidden_layer) image_feature_extract_model.summary() # 对文件目录去重 encode_train = sorted(set(img_filename)) # 图片数据集 image_dataset = tf.data.Dataset.from_tensor_slices(encode_train).map(load_image).batch(batch_size) for img, path in image_dataset: batch_feature = image_feature_extract_model(img) print(batch_feature.shape) batch_feature = tf.reshape(batch_feature, (batch_feature.shape[0], -1, batch_feature.shape[3])) print(batch_feature.shape) for bf, p in zip(batch_feature, path): path_of_feature = p.numpy().decode('utf-8') np.save(numpyPATH + path_of_feature, bf.numpy())
def model_pretraining(model_name, num_labels): if model_name.lower() == 'resnet50': restnet_base_model = ResNet50(weights='imagenet', include_top=False, input_shape=input_shape) x = Flatten()(restnet_base_model.get_output_at(-1)) x = Dense(64, activation='relu')(x) output = Dense(num_labels, activation='sigmoid')(x) model = Model(restnet_base_model.input, output, name='resnet') elif model_name.lower() == 'inceptionv3': inception_base_model = InceptionV3(weights='imagenet', include_top=False, input_shape=input_shape) x = Flatten()(inception_base_model.get_output_at(-1)) x = Dense(64, activation='relu')(x) output = Dense(num_labels, activation='sigmoid')(x) model = Model(inception_base_model.input, output, name='inception') elif model_name.lower() == 'xception': xception_base_model = Xception(weights='imagenet', include_top=False, input_shape=input_shape) x = Flatten()(xception_base_model.get_output_at(-1)) x = Dense(64, activation='relu')(x) output = Dense(num_labels, activation='sigmoid')(x) model = Model(xception_base_model.input, output, name='xception') elif model_name.lower() == 'densenet': xception_base_model = DenseNet121(weights='imagenet', include_top=False, input_shape=input_shape) x = Flatten()(xception_base_model.get_output_at(-1)) x = Dense(64, activation='relu')(x) output = Dense(num_labels, activation='sigmoid')(x) model = Model(xception_base_model.input, output, name='densenet') elif model_name.lower() == 'inceptionresnet': xception_base_model = DenseNet121(weights='imagenet', include_top=False, input_shape=input_shape) x = Flatten()(xception_base_model.get_output_at(-1)) x = Dense(64, activation='relu')(x) output = Dense(num_labels, activation='sigmoid')(x) model = Model(xception_base_model.input, output, name='inceptionresnet') else: raise ValueError('Invalid model name!') return model
def run_model(args): # Configure the memory optimizer #gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333) config = tf.ConfigProto() config.graph_options.rewrite_options.memory_optimization = rewriter_config_pb2.RewriterConfig.SCHEDULING_HEURISTICS #config.gpu_options.allow_growth=True config.gpu_options.per_process_gpu_memory_fraction = 0.5 K.set_session(tf.Session(config=config)) num_classes = args.num_classes batch_size = args.batch_size model_name = args.model if model_name == 'ResNet50': model = ResNet50(weights=None, include_top=True, input_shape=input_shape, classes=num_classes)
def network(hidden_units): input = Input(shape=IMAGE_SHAPE, name=INPUT_NAME) conv_base = ResNet50(weights='imagenet', include_top=False, pooling = 'avg', input_tensor=input) for layer in conv_base.layers: layer.trainable = False a = Flatten()(conv_base.output) a = Dense(hidden_units, activation='relu')(a) y = Dense(NUM_CLASSES, activation='softmax')(a) model = Model(inputs=input, outputs=y) return model
def makenumpyfeature(numpyPATH, img_filename, PATH): if os.path.exists(numpyPATH): shutil.rmtree(numpyPATH, ignore_errors=True) os.mkdir(numpyPATH) size = [224, 224] batchsize = 10 def load_image(image_path): img = tf.read_file(PATH + image_path) img = tf.image.decode_jpeg(img, channels=3) img = tf.image.resize(img, size) img = tf.keras.applications.resnet50.preprocess_input(img) return img, image_path image_model = ResNet50( weights='resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', include_top=False) #创建ResNet网络 new_input = image_model.input hidden_layer = image_model.layers[-2].output #获取ResNet的倒数第二层(池化前的卷积结果) image_features_extract_model = tf.keras.Model(new_input, hidden_layer) #对文件目录去重 encode_train = sorted(set(img_filename)) #图片数据集 image_dataset = tf.data.Dataset.from_tensor_slices(encode_train).map( load_image).batch(batchsize) for img, path in image_dataset: batch_features = image_features_extract_model(img) print(batch_features.shape) batch_features = tf.reshape( batch_features, (batch_features.shape[0], -1, batch_features.shape[3])) print(batch_features.shape) for bf, p in zip(batch_features, path): path_of_feature = p.numpy().decode("utf-8") np.save(numpyPATH + path_of_feature, bf.numpy())
def Mildnet_resnet(): model = ResNet50(include_top=False, weights='imagenet', input_shape=(224, 224, 3), pooling='avg') for layer in model.layers[:143]: layer.trainable = False intermediate_layer_outputs = get_layers_output_by_name(model, ['activation_46', 'activation_43']) convnet_output = model.output for layer_name, output in intermediate_layer_outputs.items(): output = GlobalAveragePooling2D()(output) convnet_output = concatenate([convnet_output, output]) convnet_output = Dense(2048, activation='relu')(convnet_output) convnet_output = Dropout(0.6)(convnet_output) convnet_output = Dense(2048, activation='relu')(convnet_output) convnet_output = Lambda(lambda x: K.l2_normalize(x, axis=1))(convnet_output) final_model = tf.keras.models.Model(inputs=model.input, outputs=convnet_output) return final_model
def create_model(input_shape, n_classes, weights_path, freeze_convnet): convnet = ResNet50( include_top=False, weights='imagenet', input_shape=input_shape) x = convnet.output x = Flatten()(x) x = Dense(n_classes, activation='softmax', name='out')(x) model = Model(inputs=convnet.input, outputs=x) # load weights if type(weights_path) is str: model.load_weights(weights_path, by_name=True) elif type(weights_path) is list: for p in weights_path: model.load_weights(p, by_name=True) if freeze_convnet: print('Freeze convolutional layers') for layer in convnet.layers: layer.trainable = False return model
def get_model(self, model_name, weights): if model_name == 'InceptionV3': from tensorflow.python.keras.applications.inception_v3 import InceptionV3 base_model = InceptionV3(weights=weights, include_top=False) elif model_name == 'NASNetLarge': from tensorflow.python.keras.applications.nasnet import NASNetLarge base_model = NASNetLarge(weights=weights, include_top=False) elif model_name == 'DenseNet201': from tensorflow.python.keras.applications.densenet import DenseNet201 base_model = DenseNet201(weights=weights, include_top=False) elif model_name == 'Xception': from tensorflow.python.keras.applications.xception import Xception base_model = Xception(weights=weights, include_top=False) elif model_name == 'VGG16': from tensorflow.python.keras.applications.vgg16 import VGG16 base_model = VGG16(weights=weights, include_top=False) elif model_name == 'VGG19': from tensorflow.python.keras.applications.vgg19 import VGG19 base_model = VGG19(weights=weights, include_top=False) elif model_name == 'NASNetMobile': from tensorflow.python.keras.applications.nasnet import NASNetMobile base_model = NASNetMobile(weights=weights, include_top=False) elif model_name == 'MobileNetV2': from tensorflow.python.keras.applications.mobilenet_v2 import MobileNetV2 base_model = MobileNetV2(weights=weights, include_top=False) elif model_name == 'ResNet50': from tensorflow.python.keras.applications.resnet50 import ResNet50 base_model = ResNet50(weights=weights, include_top=False) elif model_name == 'InceptionResNetV2': from tensorflow.python.keras.applications.inception_resnet_v2 import InceptionResNetV2 base_model = InceptionResNetV2(weights=weights, include_top=False, ) else: raise KeyError('Unknown network.') x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) predictions = Dense(1, activation='sigmoid')(x) model = Model(inputs=base_model.input, outputs=predictions) return model
def get_model(self, model_name, weights='imagenet'): if model_name == 'InceptionV3': from tensorflow.python.keras.applications.inception_v3 import InceptionV3 base_model = InceptionV3(weights=weights, include_top=False) elif model_name == 'NASNetLarge': from tensorflow.python.keras.applications.nasnet import NASNetLarge base_model = NASNetLarge(weights=weights, include_top=False) elif model_name == 'DenseNet201': from tensorflow.python.keras.applications.densenet import DenseNet201 base_model = DenseNet201(weights=weights, include_top=False) elif model_name == 'Xception': from tensorflow.python.keras.applications.xception import Xception base_model = Xception(weights=weights, include_top=False) elif model_name == 'VGG19': from tensorflow.python.keras.applications.vgg19 import VGG19 base_model = VGG19(weights=weights, include_top=False) elif model_name == 'NASNetMobile': from tensorflow.python.keras.applications.nasnet import NASNetMobile base_model = NASNetMobile(weights=weights, include_top=False) elif model_name == 'MobileNetV2': from tensorflow.python.keras.applications.mobilenet_v2 import MobileNetV2 base_model = MobileNetV2(weights=weights, include_top=False) elif model_name == 'ResNet50': from tensorflow.python.keras.applications.resnet50 import ResNet50 base_model = ResNet50(weights=weights, include_top=False) elif model_name == 'InceptionResNetV2': from tensorflow.python.keras.applications.inception_resnet_v2 import InceptionResNetV2 base_model = InceptionResNetV2(weights=weights, include_top=False) else: raise KeyError('Unknown network.') x = base_model.output x = GlobalAveragePooling2D()(x) # x = Dense(1024, activation='relu')(x) output = Dense(1, activation='sigmoid')(x) # output = SiameseLossLayer(self.batch_size, self.num_distort, self.num_level)(x) model = Model(inputs=base_model.input, outputs=output) self.name = model_name return model
def get_model(batch_size, train=True): resnet = ResNet50(include_top=False, weights=None, input_tensor=None, input_shape=None, pooling=None) top_model = TopModel() input = Input(shape=[256, 256, 3], batch_size=batch_size) output = resnet(input) print("resnet output shape:", output.shape) out = top_model(output) prediction = out[0] heatmap = out[1] # set proper names for outputs prediction = Activation('linear', name="xyz")(prediction) heatmap = Activation('linear', name="mask")(heatmap) if train: model = tf.keras.models.Model(inputs=[input], outputs=[prediction, heatmap]) else: model = tf.keras.models.Model(inputs=[input], outputs=[prediction]) return model
def run_model(args): # Configure the memory optimizer #gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333) config = tf.ConfigProto() config.graph_options.rewrite_options.memory_optimization = rewriter_config_pb2.RewriterConfig.SCHEDULING_HEURISTICS #config.gpu_options.allow_growth=True config.gpu_options.per_process_gpu_memory_fraction = 0.5 K.set_session(tf.Session(config=config)) num_classes = args.num_classes batch_size = args.batch_size model_name = args.model if model_name == 'ResNet50': model = ResNet50(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'ResNet101': model = keras.applications.resnet.ResNet101(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'ResNet152': model = ResNet152(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'VGG16': model = VGG16(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'VGG19': model = VGG19(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'Xception': model = Xception(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'MobileNet': model = MobileNet(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'MobileNetV2': model = MobilenetV2(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) elif model_name == 'InceptionV3': model = InceptionV3(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) else: print('Running with ResNet50 -- the default model') model = ResNet50(weights=None, include_top=True, input_shape=input_shape, classes=num_classes) execute_model(model, input_shape)
def fit(self, learning_rate=1e-4, epochs=5, activation='relu', dropout=0, hidden_size=1024, nb_layers=1, include_class_weight=False, batch_size=20, save_model=False, verbose=True, fine_tuning=False, NB_IV3_LAYERS_TO_FREEZE=279, use_TPU=False, transfer_model='Inception', min_accuracy=None, extract_SavedModel=False): if transfer_model in ['Inception', 'Xception', 'Inception_Resnet']: target_size = (299, 299) else: target_size = (224, 224) #We expect the classes to be the name of the folders in the training set self.categories = os.listdir(TRAIN_DIR) """ helper functions to to build tensors inspired by https://www.tensorflow.org/tutorials/load_data/images """ def prepare_image(img_path): #reshape the image image = Image.open(img_path) image = image.resize(target_size, PIL.Image.BILINEAR).convert("RGB") #convert the image into a numpy array, and expend to a size 4 tensor image = img_to_array(image) #rescale the pixels to a 0-1 range image = image.astype(np.float32) / 255 return image def generate_tuples(img_folder): #loop through all the images # Get all file names of images present in folder classes = os.listdir(img_folder) classes_paths = [ os.path.abspath(os.path.join(img_folder, i)) for i in classes ] x = [] y = [] for i, j in enumerate(classes): #for all the classes, get the list of pictures img_paths = os.listdir(classes_paths[i]) img_paths = [ os.path.abspath(os.path.join(classes_paths[i], x)) for x in img_paths ] for img_path in img_paths: x.append(prepare_image(img_path)) y = y + [i] return (np.array(x), np.array(y).astype(np.int32)) #get training data (x_train, y_train) = generate_tuples(parentdir + '/data/image_dataset/train') (x_val, y_val) = generate_tuples(parentdir + '/data/image_dataset/val') #train input_function: see https://colab.research.google.com/drive/1F8txK1JLXKtAkcvSRQz2o7NSTNoksuU2#scrollTo=abbwQQfH0td3 def get_training_dataset(batch_size=batch_size): # Convert the inputs to a Dataset. dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) # Shuffle, repeat, and batch the examples. dataset = dataset.shuffle(1000).repeat().batch(batch_size, drop_remainder=True) return dataset def get_validation_dataset(batch_size=batch_size): # Convert the inputs to a Dataset. dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val)) # Shuffle, repeat, and batch the examples. dataset = dataset.shuffle(1000).repeat().batch(batch_size, drop_remainder=True) return dataset #if we want stop training when no sufficient improvement in accuracy has been achieved if min_accuracy is not None: callback = EarlyStopping(monitor='acc', baseline=min_accuracy) callback = [callback] else: callback = None #load the pretrained model, without the classification (top) layers if transfer_model == 'Xception': base_model = Xception(weights='imagenet', include_top=False, input_shape=(299, 299, 3)) elif transfer_model == 'Inception_Resnet': base_model = InceptionResNetV2(weights='imagenet', include_top=False, input_shape=(299, 299, 3)) elif transfer_model == 'Resnet': base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) else: base_model = InceptionV3(weights='imagenet', include_top=False, input_shape=(299, 299, 3)) #Add the classification layers using Keras functional API x = base_model.output x = GlobalAveragePooling2D()(x) for _ in range(nb_layers): x = Dense(hidden_size, activation=activation)( x) #Hidden layer for classification if dropout > 0: x = Dropout(rate=dropout)(x) predictions = Dense(len(self.categories), activation='softmax')(x) #Output layer model = Model(inputs=base_model.input, outputs=predictions) #Set only the top layers as trainable (if we want to do fine-tuning, #we can train the base layers as a second step) for layer in base_model.layers: layer.trainable = False #Define the optimizer and the loss, and compile the model loss = 'sparse_categorical_crossentropy' if use_TPU: #if we want to try out the TPU, it looks like we currently need to use #tensorflow optimizers...see https://stackoverflow.com/questions/52940552/valueerror-operation-utpu-140462710602256-varisinitializedop-has-been-marked #...and https://www.youtube.com/watch?v=jgNwywYcH4w optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) model.compile(optimizer=optimizer, loss=sparse_softmax_cross_entropy, metrics=['acc']) TPU_WORKER = 'grpc://' + os.environ['COLAB_TPU_ADDR'] model = tf.contrib.tpu.keras_to_tpu_model( model, strategy=tf.contrib.tpu.TPUDistributionStrategy( tf.contrib.cluster_resolver.TPUClusterResolver( TPU_WORKER))) tf.logging.set_verbosity(tf.logging.INFO) else: optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) model.compile(optimizer=optimizer, loss=loss, metrics=['acc']) #if we want to weight the classes given the imbalanced number of images if include_class_weight: from sklearn.utils.class_weight import compute_class_weight cls_train = self.categories class_weight = compute_class_weight(class_weight='balanced', classes=np.unique(cls_train), y=cls_train) else: class_weight = None steps_per_epoch = int( sum([ len(files) for r, d, files in os.walk(parentdir + '/data/image_dataset/train') ]) / batch_size) validation_steps = int( sum([ len(files) for r, d, files in os.walk(parentdir + '/data/image_dataset/val') ]) / batch_size) #Fit the model if use_TPU: history = model.fit(get_training_dataset, steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data=get_validation_dataset, validation_steps=validation_steps, verbose=verbose, callbacks=callback, class_weight=class_weight) else: history = model.fit(get_training_dataset(), steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data=get_validation_dataset(), validation_steps=validation_steps, verbose=verbose, callbacks=callback, class_weight=class_weight) #Fine-tune the model, if we wish so if fine_tuning and not model.stop_training: print('============') print('Begin fine-tuning') print('============') #declare the first layers as trainable for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]: layer.trainable = False for layer in model.layers[NB_IV3_LAYERS_TO_FREEZE:]: layer.trainable = True model.compile(optimizer=tf.train.AdamOptimizer( learning_rate=learning_rate * 0.1), loss=loss, metrics=['acc']) #Fit the model if use_TPU: history = model.fit(get_training_dataset, steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data=get_validation_dataset, validation_steps=validation_steps, verbose=verbose, callbacks=callback, class_weight=class_weight) else: history = model.fit(get_training_dataset(), steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data=get_validation_dataset(), validation_steps=validation_steps, verbose=verbose, callbacks=callback, class_weight=class_weight) #Evaluate the model, just to be sure self.fitness = history.history['val_categorical_accuracy'][-1] #Save the model if save_model: if not os.path.exists(parentdir + '/data/trained_models'): os.makedirs(parentdir + '/data/trained_models') model.save(parentdir + '/data/trained_models/trained_model.h5') print('Model saved!') #save model in production format if extract_SavedModel: export_path = "./image_classifier/1/" with K.get_session() as sess: tf.saved_model.simple_save( sess, export_path, inputs={'input_image': model.input}, outputs={t.name: t for t in model.outputs}) else: self.model = model del history del model
valid_datagen = ImageDataGenerator() valid_batches = valid_datagen.flow_from_directory(DATASET_PATH + '/test1', target_size=IMAGE_SIZE, interpolation='bicubic', class_mode='categorical', shuffle=False, batch_size=BATCH_SIZE) # Output class index for cls, idx in train_batches.class_indices.items(): print('Class #{} = {}'.format(idx, cls)) net = ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=INPUT_SHAPE, classes=NUM_CLASSES) x = net.output x = Flatten()(x) # add DropOut layer x = Dropout(0.5)(x) #Fully connected layer 1 fc1 = tf.keras.layers.Dense(100, activation='relu', name="AddedDense1")(x) # Use softmax output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(fc1) net_final = Model(inputs=net.input, outputs=output_layer)