from keras.layers import Dense, GlobalAveragePooling2D, Dropout, BatchNormalization from keras.models import Model from keras.applications import MobileNet, MobileNetV2 model1 = MobileNet(weights='imagenet', input_shape=(224, 224, 3)) model2 = MobileNet(weights='imagenet', input_shape=(224, 224, 3), include_top=False) model3 = MobileNetV2(weights='imagenet', input_shape=(224, 224, 3)) print(len(model1.layers)) print(len(model3.layers))
plt.plot(y[:, 2]) plt.ylabel('reward') plt.subplot(514) plt.plot(y[:, 3]) plt.ylabel('epsilon') plt.subplot(515) plt.plot(y[:, 4]) plt.ylabel('action') plt.pause(0.0001) if __name__ == '__main__': # images_dir = '/home/hsli/gnode02/imagenet-data/train/' images_dir = '/home/imagenet-data/train/' feature_extractor = MobileNetV2(include_top=False) x = feature_extractor.output x = AveragePooling2D(pool_size=(4, 4))(x) feature_extractor = Model(inputs=feature_extractor.input, outputs=x) rm = ResultManager('evaluation_results') agent_acc_size_dict = [] origin_acc_size_dict = [] agent = DQN_Agent(s_dim=1280, a_dim=10, epsilon_decay=0.99, epsilon_min=0.02, gamma=0.95, replay_batchsize=256)
import cv2 #%% # mbv2 = MobileNetV2(include_top=True) # mbv2.save("mbv2.h5") #%% 超参数 batch_size = 64 cols = 320 rows = 180 channels = 3 # train_dir = "/home/stephan/datasets/驭势科技/dataset/dataset/train" train_dir = r"C:\Users\xps\Documents\Python Scripts\keras" epochs_initial = 2 epochs_finetune = 5 train_test_ratio = 5 #%% 构建网络 mbv2 = MobileNetV2(include_top=False,input_shape=(rows,cols,channels)) # x = mbv2.get_layer("Conv_1_bn").output x = mbv2.output x = AveragePooling2D() (x) # x = Dense(100,activation='relu') (x) x = Dense(1000,activation='relu') (x) x = Dense(100,activation='relu') (x) predictions = Dense(2,activation='relu') (x) mbv2_self_driving = Model(input=mbv2.input, output=predictions) mbv2_self_driving.save("mbv2_self_driving.h5") #%% 冻结卷积层 for layer in mbv2_self_driving.layers[:-3]: layer.trainable = False #%% 查看可更新层 # for layer in mbv2_self_driving.layers: # print(layer.trainable)
def SSD(input_shape, num_classes): """SSD300 architecture. # Arguments input_shape: Shape of the input image, expected to be either (300, 300, 3) or (3, 300, 300)(not tested). num_classes: Number of classes including background. # References https://arxiv.org/abs/1512.02325 """ alpha = 1.0 img_size = (input_shape[1], input_shape[0]) input_shape = (input_shape[1], input_shape[0], 3) mobilenetv2_input_shape = (224, 224, 3) mobilenetv2_input_shape = (300, 300, 3) Input0 = Input(input_shape) mobilenetv2 = MobileNetV2(input_shape=mobilenetv2_input_shape, include_top=False) FeatureExtractor = Model( inputs=mobilenetv2.input, outputs=mobilenetv2.get_layer('block_12_add').output) #get_3rd_layer_output = K.function([mobilenetv2.layers[114].input, K.learning_phase()], # [mobilenetv2.layers[147].output]) x = FeatureExtractor(Input0) x, pwconv3 = _isb4conv13(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=13) #x=get_3rd_layer_output([x,1])[0] x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=14) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=15) x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, expansion=6, block_id=16) x, pwconv4 = Conv(x, 1280) x, pwconv5 = LiteConv(x, 5, 512) x, pwconv6 = LiteConv(x, 6, 256) x, pwconv7 = LiteConv(x, 7, 128) x, pwconv8 = LiteConv(x, 8, 128) pwconv3_mbox_loc_flat, pwconv3_mbox_conf_flat, pwconv3_mbox_priorbox = prediction( pwconv3, 3, 3, 60.0, None, [2], num_classes, img_size) pwconv4_mbox_loc_flat, pwconv4_mbox_conf_flat, pwconv4_mbox_priorbox = prediction( pwconv4, 4, 6, 105.0, 150.0, [2, 3], num_classes, img_size) pwconv5_mbox_loc_flat, pwconv5_mbox_conf_flat, pwconv5_mbox_priorbox = prediction( pwconv5, 5, 6, 150.0, 195.0, [2, 3], num_classes, img_size) pwconv6_mbox_loc_flat, pwconv6_mbox_conf_flat, pwconv6_mbox_priorbox = prediction( pwconv6, 6, 6, 195.0, 240.0, [2, 3], num_classes, img_size) pwconv7_mbox_loc_flat, pwconv7_mbox_conf_flat, pwconv7_mbox_priorbox = prediction( pwconv7, 7, 6, 240.0, 285.0, [2, 3], num_classes, img_size) pwconv8_mbox_loc_flat, pwconv8_mbox_conf_flat, pwconv8_mbox_priorbox = prediction( pwconv8, 8, 6, 285.0, 300.0, [2, 3], num_classes, img_size) # Gather all predictions mbox_loc = concatenate([ pwconv3_mbox_loc_flat, pwconv4_mbox_loc_flat, pwconv5_mbox_loc_flat, pwconv6_mbox_loc_flat, pwconv7_mbox_loc_flat, pwconv8_mbox_loc_flat ], axis=1, name='mbox_loc') mbox_conf = concatenate([ pwconv3_mbox_conf_flat, pwconv4_mbox_conf_flat, pwconv5_mbox_conf_flat, pwconv6_mbox_conf_flat, pwconv7_mbox_conf_flat, pwconv8_mbox_conf_flat ], axis=1, name='mbox_conf') mbox_priorbox = concatenate([ pwconv3_mbox_priorbox, pwconv4_mbox_priorbox, pwconv5_mbox_priorbox, pwconv6_mbox_priorbox, pwconv7_mbox_priorbox, pwconv8_mbox_priorbox ], axis=1, name='mbox_priorbox') if hasattr(mbox_loc, '_keras_shape'): num_boxes = mbox_loc._keras_shape[-1] // 4 elif hasattr(mbox_loc, 'int_shape'): num_boxes = K.int_shape(mbox_loc)[-1] // 4 mbox_loc = Reshape((num_boxes, 4), name='mbox_loc_final')(mbox_loc) mbox_conf = Reshape((num_boxes, num_classes), name='mbox_conf_logits')(mbox_conf) mbox_conf = Activation('softmax', name='mbox_conf_final')(mbox_conf) predictions = concatenate([mbox_loc, mbox_conf, mbox_priorbox], axis=2, name='predictions') model = Model(inputs=Input0, outputs=predictions) return model
from keras.applications import MobileNetV2 from keras.models import Sequential, Model from keras.layers import Dense, Dropout, Activation, Flatten, GlobalAveragePooling2D from keras.optimizers import RMSprop, Adam, SGD from keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau from keras.preprocessing.image import ImageDataGenerator import glob # 전역변수 img_rows, img_cols = 224, 224 mobilenet = MobileNetV2(weights='imagenet', include_top=False, input_shape=(img_rows, img_cols, 3)) train_data_dir = './data/train' valid_data_dir = './data/validation' num_classes = 2 batch_size = 32 for layer in mobilenet.layers: layer.trainable = True def addTopModelMobileNet(bottom_model, num_classes): top_model = bottom_model.output top_model = GlobalAveragePooling2D()(top_model) top_model = Dense(4096, activation='relu')(top_model) top_model = Dropout(0.3)(top_model) top_model = Dense(4096, activation='relu')(top_model) top_model = Dropout(0.3)(top_model) top_model = Dense(2048, activation='relu')(top_model) top_model = Dropout(0.5)(top_model)
def build_model(name='vgg16', filepath=None, training=False, continuing=True): model = None base = None shape = config.IMAGE_DIMENSIONS checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') if os.path.exists(filepath) and training and continuing: model = load_model(filepath) return model, checkpoint, shape name = name.lower() if name == 'vgg16': base = VGG16() elif name == 'vgg19': base = VGG19() elif name == 'xception': base = Xception() shape = config.IMAGE_DIMENSIONS_299 elif name == 'inceptionv3': base = InceptionV3() shape = config.IMAGE_DIMENSIONS_299 elif name == 'resnet50': base = ResNet50() elif name == 'mobilenetv2': base = MobileNetV2() elif name == 'densenet121': base = DenseNet121() elif name == 'densenet169': base = DenseNet169() elif name == 'densenet201': base = DenseNet201() elif name == 'inceptionresnetv2': base = InceptionResNetV2() shape = config.IMAGE_DIMENSIONS_299 elif name == 'nasnetmobile': base = NASNetMobile() elif name == 'control': input = Input(shape=config.IMAGE_SHAPE) base = Conv2D(input_shape=config.IMAGE_SHAPE, filters=16, kernel_size=3, activation='relu')(input) base = MaxPooling2D()(base) base = Flatten()(base) base = Model(inputs=input, output = base) if name != 'control': for layer in base.layers: layer.trainable = False x = Dense(1024, activation='relu')(base.output) x = BatchNormalization()(x) x = Dropout(0.7)(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) x = Dense(2, activation='softmax')(x) model = Model(inputs=base.input, outputs=x) if os.path.exists(filepath): model.load_weights(filepath) return model, checkpoint, shape
from keras.applications import MobileNetV2 from keras.preprocessing import image from tqdm import tqdm from PIL import Image import numpy as np import tensorflow as tf import os from numpy import savez_compressed files = os.listdir('data') enc = np.zeros((len(files), 1000)) model = MobileNetV2(classifier_activation=None) for i in tqdm(range(len(files)), desc="Encoding files..", unit="file"): try: im = np.asarray( image.load_img('data/' + files[i], target_size=(224, 224))) im = im[:, :, :3] / 225 e = model.predict(np.expand_dims(im, axis=0)) enc[i, :] = e[0, :] except: print("Error reading image:" + files[i]) savez_compressed("data.npz", enc)
import os import time import cv2 from keras.preprocessing import image from keras.applications.vgg16 import VGG16 from keras.applications import MobileNetV2 from keras.applications.vgg16 import preprocess_input import numpy as np model = MobileNetV2(weights='imagenet', include_top=False) def get_image_content(image): image = cv2.resize(image, dsize=(224, 224), interpolation=cv2.INTER_CUBIC) image = np.expand_dims(image, axis=0) img_data = preprocess_input(image) features = model.predict(img_data) print(features.shape) return features
from keras.layers import Dense from keras.applications import MobileNetV2 datagen = ImageDataGenerator(rescale=1./255,shear_range=0.2,zoom_range=0.3) train_generator = datagen.flow_from_directory('data/dataset/train', target_size=(224, 224), batch_size=64, class_mode='categorical') test_generator = datagen.flow_from_directory('data/dataset/test', target_size=(224, 224), batch_size=64, class_mode='categorical') mobile = MobileNetV2(include_top=False, weights="imagenet", input_shape=(224,224,3), pooling="avg") model = Sequential() model.add(mobile) model.add(Dense(5, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit_transform(train_generator, epochs=10, steps_per_epoch=2360/64, validation_data=test_generator, validation_steps=263/64) model.save('data/model.h5')
def prepare(self): print("Setting up CNN v8..") if not os.path.exists(self.cnn_dir): os.makedirs(self.cnn_dir) ImageFile.LOAD_TRUNCATED_IMAGES = True # Rescale all images by 1./255 and apply image augmentation train_datagen = ImageDataGenerator(shear_range=0.2, zoom_range=0.2, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, rescale=1. / 255) validation_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) self.train_generator = train_datagen.flow_from_directory( self.train_dir, target_size=(self.img_width, self.img_height), batch_size=self.batch_size, class_mode='categorical') self.validation_generator = validation_datagen.flow_from_directory( self.validation_dir, target_size=(self.img_width, self.img_height), batch_size=self.batch_size, class_mode='categorical') self.test_generator = test_datagen.flow_from_directory( self.test_dir, target_size=(self.img_width, self.img_height), batch_size=self.batch_size, class_mode='categorical') print("Generators are ready, saving class indices") np.save((self.cnn_dir + "class_indices.npy"), self.train_generator.class_indices) self.IMG_SHAPE = (self.img_width, self.img_height, 3) self.num_classes = len(self.train_generator.class_indices) print("Creating transfer train model") # Create the base model from the pre-trained model MobileNet V2 on imagenet data self.base_model = MobileNetV2(input_shape=self.IMG_SHAPE, include_top=False, weights='imagenet') # its already trained, we just use the features self.base_model.trainable = False top_model = Sequential() top_model.add(GlobalAveragePooling2D()) top_model.add( Dense(128, activation='relu', kernel_regularizer=l2(0.01))) top_model.add(Dropout(0.5)) top_model.add(Dense(64, activation='relu', kernel_regularizer=l2(0.01))) top_model.add(Dropout(0.5)) top_model.add(Dense(64, activation='relu', kernel_regularizer=l2(0.01))) top_model.add(Dropout(0.5)) top_model.add( Dense(self.num_classes, activation='softmax', kernel_regularizer=l2(0.01))) self.model = Model(input=self.base_model.input, output=top_model(self.base_model.output)) self.model.compile(optimizer=RMSprop(lr=self.learning_rate), loss='categorical_crossentropy', metrics=['accuracy']) print("Model created for id %s" % self.id) self.steps_per_epoch = self.train_generator.n // self.batch_size self.validation_steps = self.validation_generator.n // self.batch_size self.test_steps = self.test_generator.n // self.batch_size print("Initializing callbacks") self.callbacks = [ EarlyStopping(monitor='val_loss', min_delta=0, patience=3, verbose=0, mode='auto'), ModelCheckpoint(filepath=(self.cnn_dir + "model-weights.h5"), verbose=1, save_best_only=True), History(), TensorBoard(log_dir="logs/{}".format(self.id)) ] try: self.model.load_weights((self.cnn_dir + "model-weights.h5")) print("Found weights for %s, loading them and continue training" % self.id) except OSError: pass print("Cnn is ready for train")
if args.weight is not None: weight_type = args.weight if weight_type == WEIGHT_TYPE_MERGE: model_weights_path = 'weights/mobilenet_v2_weights.h5' elif weight_type == WEIGHT_TYPE_AVA: model_weights_path = 'weights/mobilenet_v2_ava_weights.h5' elif weight_type == WEIGHT_TYPE_TID: model_weights_path = 'weights/mobilenet_v2_tid_weights.h5' else: model_weights_path = 'weights/mobilenet_v2_weights.h5' with tf.device('/CPU:0'): base_model = MobileNetV2((None, None, 3), alpha=1.0, include_top=False, pooling='avg', weights=None) x = Dropout(0.75)(base_model.output) x = Dense(10, activation='softmax')(x) model = Model(base_model.input, x) model.load_weights(model_weights_path) score_list = [] for img_path in imgs: img = load_img(img_path, target_size=target_size) x = img_to_array(img) x = np.expand_dims(x, axis=0)
def convolutional(instruction=None, read_mode=None, preprocess=True, data_path=None, verbose=0, new_folders=True, image_column=None, training_ratio=0.8, augmentation=True, custom_arch=None, pretrained=None, epochs=10, height=None, width=None, save_as_tfjs=None, save_as_tflite=None, generate_plots=True): ''' Body of the convolutional function used that is called in the neural network query if the data is presented in images. :param many parameters: used to preprocess, tune, plot generation, and parameterizing the convolutional neural network trained. :return dictionary that holds all the information for the finished model. ''' # data_path = get_folder_dir() logger("Generating datasets for classes") if pretrained: if not height: height = 224 if not width: width = 224 if height != 224 or width != 224: raise ValueError( "For pretrained models, both 'height' and 'width' must be 224." ) if preprocess: if custom_arch: raise ValueError( "If 'custom_arch' is not None, 'preprocess' must be set to false." ) read_mode_info = set_distinguisher(data_path, read_mode) read_mode = read_mode_info["read_mode"] training_path = "/proc_training_set" testing_path = "/proc_testing_set" if read_mode == "setwise": processInfo = setwise_preprocessing(data_path, new_folders, height, width) if not new_folders: training_path = "/training_set" testing_path = "/testing_set" # if image dataset in form of csv elif read_mode == "csvwise": if training_ratio <= 0 or training_ratio >= 1: raise BaseException(f"Test ratio must be between 0 and 1.") processInfo = csv_preprocessing(read_mode_info["csv_path"], data_path, instruction, image_column, training_ratio, height, width) # if image dataset in form of one folder containing class folders elif read_mode == "classwise": if training_ratio <= 0 or training_ratio >= 1: raise BaseException(f"Test ratio must be between 0 and 1.") processInfo = classwise_preprocessing(data_path, training_ratio, height, width) else: training_path = "/training_set" testing_path = "/testing_set" processInfo = already_processed(data_path) num_channels = 3 color_mode = 'rgb' if processInfo["gray_scale"]: num_channels = 1 color_mode = 'grayscale' input_shape = (processInfo["height"], processInfo["width"], num_channels) input_single = (processInfo["height"], processInfo["width"]) num_classes = processInfo["num_categories"] loss_func = "" output_layer_activation = "" if num_classes > 2: loss_func = "categorical_crossentropy" output_layer_activation = "softmax" elif num_classes == 2: num_classes = 1 loss_func = "binary_crossentropy" output_layer_activation = "sigmoid" logger("Creating convolutional neural network dynamically") # Convolutional Neural Network # Build model based on custom_arch configuration if given if custom_arch: with open(custom_arch, "r") as f: custom_arch_dict = json.load(f) custom_arch_json_string = json.dumps(custom_arch_dict) model = model_from_json(custom_arch_json_string) # Build an existing state-of-the-art model elif pretrained: arch_lower = pretrained.get('arch').lower() # If user specifies value of pretrained['weights'] as 'imagenet', weights pretrained on ImageNet will be used if 'weights' in pretrained and pretrained.get('weights') == 'imagenet': # Load ImageNet pretrained weights if arch_lower == "vggnet16": base_model = VGG16(include_top=False, weights='imagenet', input_shape=input_shape) x = Flatten()(base_model.output) x = Dense(4096)(x) x = Dropout(0.5)(x) x = Dense(4096)(x) x = Dropout(0.5)(x) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "vggnet19": base_model = VGG19(include_top=False, weights='imagenet', input_shape=input_shape) x = Flatten()(base_model.output) x = Dense(4096)(x) x = Dropout(0.5)(x) x = Dense(4096)(x) x = Dropout(0.5)(x) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "resnet50": base_model = ResNet50(include_top=False, weights='imagenet', input_shape=input_shape) x = Flatten()(base_model.output) x = GlobalAveragePooling2D()(base_model.output) x = Dropout(0.5)(x) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "resnet101": base_model = ResNet101(include_top=False, weights='imagenet', input_shape=input_shape) x = GlobalAveragePooling2D()(base_model.output) x = Dropout(0.5)(x) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "resnet152": base_model = ResNet152(include_top=False, weights='imagenet', input_shape=input_shape) x = GlobalAveragePooling2D()(base_model.output) x = Dropout(0.5)(x) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "mobilenet": base_model = MobileNet(include_top=False, weights='imagenet', input_shape=input_shape) x = fine_tuned_model(base_model) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "mobilenetv2": base_model = MobileNetV2(include_top=False, weights='imagenet', input_shape=input_shape) x = fine_tuned_model(base_model) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "densenet121": base_model = DenseNet121(include_top=False, weights='imagenet', input_shape=input_shape) x = fine_tuned_model(base_model) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "densenet169": base_model = DenseNet169(include_top=False, weights='imagenet', input_shape=input_shape) x = fine_tuned_model(base_model) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) elif arch_lower == "densenet201": base_model = DenseNet201(include_top=False, weights='imagenet', input_shape=input_shape) x = fine_tuned_model(base_model) pred = Dense(num_classes, activation=output_layer_activation)(x) model = Model(base_model.input, pred) else: raise ModuleNotFoundError("arch \'" + pretrained.get('arch') + "\' not supported.") else: # Randomly initialized weights if arch_lower == "vggnet16": model = VGG16(include_top=True, weights=None, classes=num_classes, classifier_activation=output_layer_activation) elif arch_lower == "vggnet19": model = VGG19(include_top=True, weights=None, classes=num_classes, classifier_activation=output_layer_activation) elif arch_lower == "resnet50": model = ResNet50(include_top=True, weights=None, classes=num_classes) elif arch_lower == "resnet101": model = ResNet101(include_top=True, weights=None, classes=num_classes) elif arch_lower == "resnet152": model = ResNet152(include_top=True, weights=None, classes=num_classes) elif arch_lower == "mobilenet": model = MobileNet(include_top=True, weights=None, classes=num_classes) elif arch_lower == "mobilenetv2": model = MobileNetV2(include_top=True, weights=None, classes=num_classes) elif arch_lower == "densenet121": model = DenseNet121(include_top=True, weights=None, classes=num_classes) elif arch_lower == "densenet169": model = DenseNet169(include_top=True, weights=None, classes=num_classes) elif arch_lower == "densenet201": model = DenseNet201(include_top=True, weights=None, classes=num_classes) else: raise ModuleNotFoundError("arch \'" + pretrained.get('arch') + "\' not supported.") else: model = Sequential() # model.add( # Conv2D( # 64, # kernel_size=3, # activation="relu", # input_shape=input_shape)) # model.add(MaxPooling2D(pool_size=(2, 2))) # model.add(Conv2D(64, kernel_size=3, activation="relu")) # model.add(MaxPooling2D(pool_size=(2, 2))) # model.add(Flatten()) # model.add(Dense(num_classes, activation="softmax")) # model.compile( # optimizer="adam", # loss=loss_func, # metrics=['accuracy']) model.add( Conv2D(filters=64, kernel_size=5, activation="relu", input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(filters=64, kernel_size=3, activation="relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Conv2D(filters=64, kernel_size=3, activation="relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(units=256, activation="relu")) model.add(Dropout(0.25)) model.add(Dense(units=num_classes, activation="softmax")) model.compile(optimizer="adam", loss=loss_func, metrics=['accuracy']) logger("Located image data") if augmentation: train_data = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_data = ImageDataGenerator(rescale=1. / 255) logger('Dataset augmented through zoom, shear, flip, and rescale') else: train_data = ImageDataGenerator() test_data = ImageDataGenerator() logger("->", "Optimal image size identified: {}".format(input_shape)) X_train = train_data.flow_from_directory( data_path + training_path, target_size=input_single, color_mode=color_mode, batch_size=(16 if processInfo["train_size"] >= 16 else 1), class_mode=loss_func[:loss_func.find("_")]) X_test = test_data.flow_from_directory( data_path + testing_path, target_size=input_single, color_mode=color_mode, batch_size=(16 if processInfo["test_size"] >= 16 else 1), class_mode=loss_func[:loss_func.find("_")]) if epochs <= 0: raise BaseException("Number of epochs has to be greater than 0.") logger('Training image model') history = model.fit_generator( X_train, steps_per_epoch=X_train.n // X_train.batch_size, validation_data=X_test, validation_steps=X_test.n // X_test.batch_size, epochs=epochs, verbose=verbose) models = [] losses = [] accuracies = [] model_data = [] model_data.append(model) models.append(history) losses.append( history.history["val_loss"][len(history.history["val_loss"]) - 1]) accuracies.append( history.history['val_accuracy'][len(history.history['val_accuracy']) - 1]) # final_model = model_data[accuracies.index(max(accuracies))] # final_hist = models[accuracies.index(max(accuracies))] plots = {} if generate_plots: plots = generate_classification_plots(models[len(models) - 1]) logger( '->', 'Final training accuracy: {}'.format( history.history['accuracy'][len(history.history['accuracy']) - 1])) logger( '->', 'Final validation accuracy: {}'.format(history.history['val_accuracy'][ len(history.history['val_accuracy']) - 1])) # storing values the model dictionary logger("Stored model under 'convolutional_NN' key") if save_as_tfjs: tfjs.converters.save_keras_model(model, "tfjsmodel") logger("Saved tfjs model under 'tfjsmodel' directory") if save_as_tflite: converter = tf.lite.TFLiteConverter.from_keras_model(model) tflite_model = converter.convert() open("model.tflite", "wb").write(tflite_model) logger("Saved tflite model as 'model.tflite' ") clearLog() K.clear_session() return { 'id': generate_id(), 'data_type': read_mode, 'data_path': data_path, 'data': { 'train': X_train, 'test': X_test }, 'shape': input_shape, "model": model, "plots": plots, 'losses': { 'training_loss': history.history['loss'], 'val_loss': history.history['val_loss'] }, 'accuracy': { 'training_accuracy': history.history['accuracy'], 'validation_accuracy': history.history['val_accuracy'] }, 'num_classes': (2 if num_classes == 1 else num_classes), 'data_sizes': { 'train_size': processInfo['train_size'], 'test_size': processInfo['test_size'] } }
def train(): # # Data Preparation # train_datagen = ImageDataGenerator( rescale = 1. / 255, shear_range = 0.2, zoom_range = 0.2, horizontal_flip = True ) val_datagen = ImageDataGenerator( rescale = 1. / 255. ) generator_kwargs = { 'target_size': (224, 224), 'batch_size': BATCH_SIZE, 'shuffle': True, 'seed': 43543 } train_generator = train_datagen.flow_from_directory( train_data_dir, **generator_kwargs ) val_generator = val_datagen.flow_from_directory( val_data_dir, **generator_kwargs ) # # Model # model = MobileNetV2( include_top = True, weights = None, classes = N_CLASSES ) model.compile( loss = 'categorical_crossentropy', optimizer = Adam(), metrics = ['accuracy'] ) # # Checkpoints # checkpoint = ModelCheckpoint( filepath = os.path.join(models_dir, 'weights.{epoch:02d}-{val_loss:.2f}.h5'), monitor = 'val_acc', verbose = 1, save_best_only = True ) tensorboard = TensorBoard(log_dir = log_dir) early_stopping = EarlyStopping( monitor = 'val_loss', patience = 2 ) callbacks = [checkpoint, tensorboard, early_stopping] # # Train # model.fit_generator( train_generator, epochs = 1, validation_data = val_generator, callbacks = callbacks )
from keras import backend as K import cv2, os import numpy as np import time class_names = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] IMAGE_SIZE = (128, 128) WEIGHTS_FINAL = 'pretrained.h5' #define the network model = MobileNetV2(input_shape=(128, 128, 3), weights=None, include_top=True, classes=10) model.load_weights(WEIGHTS_FINAL, by_name=True, skip_mismatch=True) image_dir = 'test_split/airplane/' image_names = os.listdir(image_dir) print(image_names[1]) start = time.time() for name in image_names: image = cv2.imread(image_dir + name) image = cv2.resize(image, (128, 128)) np_image_data = np.asarray(image) np_final = np.expand_dims(np_image_data, axis=0) predict = model.predict(np_final)
def load_MobileNetV2_model(): # MobileNetV2 Model 224x224 settings.SITE_MODEL = MobileNetV2(weights="imagenet") # # ResNet50 Model 224x224 # settings.SITE_MODEL = ResNet50(weights="imagenet") settings.SITE_GRAPH = tf.get_default_graph()
def augmented_MobileNetV2_model(): # Fine tuning MobileNetV2 patience = 10 batch_size = 20 epochs = 50 # create the base pre-trained model base_model = MobileNetV2(weights='imagenet', include_top=False) base_model.summary() x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(5, activation='softmax')(x) # this is the model we will train mobilenetV2_model = Model(inputs=base_model.input, outputs=predictions) # we chose to train the top 2 inception blocks, i.e. we will freeze # the first 249 layers and unfreeze the rest: for layer in mobilenetV2_model.layers[:70]: layer.trainable = False for layer in mobilenetV2_model.layers[70:]: layer.trainable = True mobilenetV2_model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.0003), metrics=['accuracy']) checkpointer = ModelCheckpoint(filepath='../saved_models/weights.best.MobileNetV2.hdf5', verbose=1, save_best_only=True) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=patience, verbose=0, mode='auto', baseline=None) # Create and configure augmented image generator datagen = ImageDataGenerator(width_shift_range=0.1, # randomly shift images horizontally (10% of total width) height_shift_range=0.1, # randomly shift images vertically (10% of total height) zoom_range=0.2) # range for random zoom) # fit augmented image generator on data datagen.fit(train_tensors) # train the model mobilenetV2_model.fit_generator( datagen.flow(train_tensors, train_targets, batch_size=batch_size), steps_per_epoch=3 * (train_tensors.shape[0] // batch_size), epochs=epochs, verbose=2, callbacks=[checkpointer, early_stopping], validation_data=(valid_tensors, valid_targets), class_weight=None, # Can pay more attention to underrepresented classes ) # load the weights that generated the best validation accuracy mobilenetV2_model.load_weights('../saved_models/weights.best.MobileNetV2.hdf5') # get index of predicted action for each image in test set action_predictions = [np.argmax(mobilenetV2_model.predict(np.expand_dims(tensor, axis=0))) for tensor in test_tensors] # report test accuracy test_accuracy = 100 * np.sum(np.array(action_predictions) == np.argmax(test_targets, axis=1)) / len( action_predictions) print('Test accuracy: %.4f%%' % test_accuracy) # Compute average prediction time computational_times = [] for i in range(50): start = time.time() mobilenetV2_model.predict(np.expand_dims(test_tensors[i], axis=0)) end = time.time() elapsed = end - start computational_times.append(elapsed) print("Average computational time per prediction: {:.3f} ms".format( np.sum(computational_times) / len(computational_times) * 1000))
def train(): global args args = parser.parse_args() img_shape = (args.img_size, args.img_size, args.img_channels ) # blame theano now_iso = datetime.now().strftime('%Y-%m-%dT%H:%M:%S%z') train_datagen = ImageDataGenerator(rescale=1. / 255, rotation_range=45, width_shift_range=0.2, height_shift_range=0.2, zoom_range=0.2, horizontal_flip=True) train_generator = train_datagen.flow_from_directory( 'data/sorted2/train', shuffle=True, target_size=(args.img_size, args.img_size), class_mode='binary', batch_size=args.batch_size, ) val_datagen = ImageDataGenerator(rescale=1. / 255) val_generator = val_datagen.flow_from_directory( 'data/sorted2/val', shuffle=True, # otherwise we get distorted batch-wise metrics class_mode='binary', target_size=(args.img_size, args.img_size), batch_size=args.batch_size, ) classes = len(train_generator.class_indices) assert classes > 0 assert classes is len(val_generator.class_indices) n_of_train_samples = train_generator.samples n_of_val_samples = val_generator.samples # Architectures base_model = MobileNetV2(input_shape=img_shape, weights='imagenet', include_top=False) x = base_model.output # Recast classification layer # x = Flatten()(x) # Uncomment for Resnet based models x = GlobalAveragePooling2D(name='predictions_avg_pool')( x) # comment for RESNET models # n_classes; softmax for multi-class, sigmoid for binary x = Dense(args.classes, activation='sigmoid', use_bias=True, name='predictions')(x) model = Model(inputs=base_model.input, outputs=x) # checkpoints checkpoint = ModelCheckpoint( filepath='./models/MobileNetV2.hdf5', verbose=0, monitor='val_binary_accuracy', save_best_only=True, ) early_stop = EarlyStopping(patience=args.early_stop) tensorboard = TensorBoard(log_dir='./logs/MobileNetV2/{}/'.format(now_iso)) # reduce_lr = ReduceLROnPlateau(factor=0.03, cooldown=0, patience=args.lr_wait, min_lr=0.1e-6) callbacks = [checkpoint, tensorboard, checkpoint, early_stop] # Calculate class weights # weights = class_weight.compute_class_weight('balanced', np.unique(train_generator.classes), train_generator.classes) # weights = {0: weights[0], 1: weights[1]} # print(model.summary()) # for i, layer in enumerate(base_model.layers): # print(i, layer.name) if args.resume: print("==> Resuming") model.load_weights(args.resume) for layer in model.layers: layer.set_trainable = True else: for layer in base_model.layers: layer.set_trainable = False # The network is trained end-to-end using Adam with default parameters model.compile( optimizer=Adam(lr=args.lr, decay=args.decay), # optimizer=SGD(lr=args.lr, decay=args.decay,momentum=args.momentum, nesterov=True), loss=binary_crossentropy, metrics=[binary_accuracy], ) model_out = model.fit_generator( train_generator, steps_per_epoch=n_of_train_samples // args.batch_size, epochs=args.epochs, validation_data=val_generator, validation_steps=n_of_val_samples // args.batch_size, # class_weight=weights, workers=args.workers, use_multiprocessing=True, callbacks=callbacks)
def mobilenetv2(): from keras.applications import MobileNetV2 model = MobileNetV2(weights='imagenet') keras2lwnn(model, 'mobilenetv2')
min_delta=0, patience=7, verbose=1) print('Starting') stage_1_epoch = 15 dropout_rate = 0.2 input_shape = (224, 224) n_classes = 5 batch_size = 4 train_annotation_path = 'train_data.txt' test_annotation_path = 'test_data.txt' """ Modify Model to Custom data """ base_model = MobileNetV2(weights='imagenet', include_top=True) # model = Xception(weights='imagenet', include_top=True) x = base_model.output x = GlobalAveragePooling2D()(x) predictions = Dense(n_classes, activation='softmax', name='probs')(x) model = Model(inputs=base_model.input, outputs=predictions) base_model.summary() """ Data Prepocessing """ with open(train_annotation_path, 'r') as f: train_lines = f.readlines() with open(test_annotation_path, 'r') as f: test_lines = f.readlines()
model.add(Dense(4096)) model.add(Activation('relu')) model.add(Dropout(0.5)) #8 model.add(Dense(257)) model.add(Activation('sigmoid')) return model # model = getAlexNet() # model.summary() # model = baseline_model() # model.summary() model = MobileNetV2(classes = 257, weights = None) model.summary() x = [] n = 2 m = 11 for i in range(0, n): x.append(model.layers.pop()) for i in range(m): model.layers.pop() for i in range(0,n): model.layers.append(x[n -i -1])
save_img('mobilenet_{0:}_{1:}x{1:}.png'.format(layer_name, n), stitched_filters) def display_activation(activations, col_size, row_size, act_index): """ https://www.kaggle.com/amarjeet007/visualize-cnn-with-keras """ activation = activations[act_index] activation_index=0 fig, ax = plt.subplots(row_size, col_size, figsize=(row_size*2.5,col_size*1.5)) for row in range(0,row_size): for col in range(0,col_size): ax[row][col].imshow(activation[0, :, :, activation_index], cmap='hsv') activation_index += 1 plt.plot() plt.show() start_time = time.time() model = MobileNetV2() # model.summary() layer_outputs = [layer.output for layer in model.layers] activation_model = Model(inputs=model.input, outputs=layer_outputs[1:-6]) imageToUse = cv2.imread('object_detection/img/bounty/gameplay_3.png')[0:705, 0:1280] input_img_data = cv2.resize(imageToUse, (224, 224)) activations = activation_model.predict(input_img_data.reshape(1, 224, 224, 3)) print(time.time() - start_time) _draw_filters(activations[1][0], 'test', output_dim=(112, 112)) # display_activation(activations, 4, 4, 128)
from keras.preprocessing.image import load_img from keras.utils import to_categorical from sklearn.preprocessing import LabelBinarizer from sklearn.model_selection import train_test_split from keras.layers import Dense, Dropout, Flatten, MaxPooling2D from imutils import paths import matplotlib.pyplot as plt import numpy as np import os from keras.models import Model import random # importing MobileNet_v2 for higher accuracy from keras.applications import MobileNetV2 mobile = MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights='imagenet') #print(mobile.summary()) # layer should not be change for layer in mobile.layers: layer.trainable = False # Make output layer of mobilenet op_layer = mobile.output op_layer = MaxPooling2D(pool_size=(6, 6))(op_layer) op_layer = Flatten()(op_layer) op_layer = Dense(128, activation='relu')(op_layer) op_layer = Dropout((0.5))(op_layer) op_layer = Dense(2, activation='softmax')(op_layer)
from keras.applications.resnet50 import ResNet50 from keras import models # from VESI import layers from keras import optimizers from keras import regularizers from keras.callbacks import ModelCheckpoint, LearningRateScheduler,CSVLogger from keras.callbacks import ReduceLROnPlateau from keras.models import Sequential from keras.layers import Activation, Dropout, Flatten, Dense target_size = (224,224) batch_size = 32 #模型 model = Sequential() model.add(MobileNetV2(include_top = False,pooling='avg', weights = 'imagenet',input_shape=(224, 224, 3))) model.trainable = False model.add(Dense(66, activation = 'softmax')) # model.layers[0].trainable = True #或者这个 # model = Sequential() # model.add(MobileNetV2(include_top = False, weights = './saved_models/TF_2_%s_model.008.h5',input_shape=(224, 224, 3))) # model.add(Dense(65, activation = 'softmax')) # model.layers[0].trainable = True #数据预处理 train_datagen = ImageDataGenerator( rescale=1./255) # shear_range=0.2, #实时图片增强 # zoom_range=0.2, # horizontal_flip=True)
shuffle=True, classes=['ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE'], class_mode='categorical') test_gen = test_datagen.flow_from_directory( './datasets/fingers/test/', target_size=(224, 224), color_mode='rgb', batch_size=nbatch, classes=['ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE'], class_mode='categorical') print(test_gen.class_indices, "\n") base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) """ x = base_model.output x = Conv2D(32, (3, 3), activation='relu')(x) x = Conv2D(64, (3, 3), activation='relu')(x) x = Conv2D(64, (3, 3), activation='relu')(x) # x = Conv2D(128, (3, 3), activation='relu')(x) x = Flatten()(x) x = Dense(512, kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01), activation='relu')(x) x = Dropout(0.5)(x) x = Dense(256, activation='relu')(x) x = Dropout(0.4)(x) preds = Dense(6, activation='softmax')(x) """
trainaug = ImageDataGenerator(rotation_range=30, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") validaug = ImageDataGenerator() mean = np.array([123.68, 116.779, 103.939], dtype="float32") trainaug.mean = mean validaug.mean = mean prtmodel = MobileNetV2(weights="imagenet", include_top=False, input_tensor=Input(shape=(224, 224, 3))) i = prtmodel.output #x = AveragePooling2D(pool_size=(7, 7))(i) x = Flatten()(i) x = Dense(1024, activation='relu')(x) x = Dense(512, activation='relu')(x) x = Dense(512, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(3, activation='softmax')(x) model = Model(inputs=prtmodel.input, outputs=x) for layer in prtmodel.layers: layer.trainable = False
def train(x_target, x_ref, y_ref, epoch_num): # VGG16読み込み, S network用 print("Model build...") #mobile = VGG16(include_top=False, input_shape=input_shape, weights='imagenet') # mobile net読み込み, S network用 mobile = MobileNetV2(include_top=True, input_shape=input_shape, alpha=alpha, weights='imagenet') #最終層削除 mobile.layers.pop() # 重みを固定 for layer in mobile.layers: if layer.name == "block_13_expand": # "block5_conv1": for VGG16 break else: layer.trainable = False model_t = Model(inputs=mobile.input, outputs=mobile.layers[-1].output) # R network用 Sと重み共有 model_r = Network(inputs=model_t.input, outputs=model_t.output, name="shared_layer") #Rに全結合層を付ける prediction = Dense(classes, activation='softmax')(model_t.output) model_r = Model(inputs=model_r.input, outputs=prediction) #コンパイル optimizer = SGD(lr=5e-5, decay=0.00005) model_r.compile(optimizer=optimizer, loss="categorical_crossentropy") model_t.compile(optimizer=optimizer, loss=original_loss) model_t.summary() model_r.summary() print("x_target is", x_target.shape[0], 'samples') print("x_ref is", x_ref.shape[0], 'samples') ref_samples = np.arange(x_ref.shape[0]) loss, loss_c = [], [] print("training...") #学習 for epochnumber in range(epoch_num): x_r, y_r, lc, ld = [], [], [], [] #ターゲットデータシャッフル np.random.shuffle(x_target) #リファレンスデータシャッフル np.random.shuffle(ref_samples) for i in range(len(x_target)): x_r.append(x_ref[ref_samples[i]]) y_r.append(y_ref[ref_samples[i]]) x_r = np.array(x_r) y_r = np.array(y_r) for i in range(int(len(x_target) / batchsize)): #batchsize分のデータロード batch_target = x_target[i * batchsize:i * batchsize + batchsize] batch_ref = x_r[i * batchsize:i * batchsize + batchsize] batch_y = y_r[i * batchsize:i * batchsize + batchsize] #target data #学習しながら、損失を取得 lc.append( model_t.train_on_batch(batch_target, np.zeros((batchsize, feature_out)))) #reference data #学習しながら、損失を取得 ld.append(model_r.train_on_batch(batch_ref, batch_y)) loss.append(np.mean(ld)) loss_c.append(np.mean(lc)) if (epochnumber + 1) % 5 == 0: print("epoch:", epochnumber + 1) print("Descriptive loss:", loss[-1]) print("Compact loss", loss_c[-1]) #結果グラフ #plt.plot(loss,label="Descriptive loss") #plt.xlabel("epoch") #plt.legend() #plt.show() #plt.plot(loss_c,label="Compact loss") #plt.xlabel("epoch") #plt.legend() #plt.show() return model_t
import os from keras.applications import MobileNetV2 from keras.applications.mobilenet_v2 import preprocess_input from keras.models import Model from keras.layers import Dropout, Dense, Input, Lambda from keras.optimizers import Adam from keras.preprocessing.image import ImageDataGenerator from keras.callbacks import ReduceLROnPlateau, EarlyStopping df = pd.read_csv('processed_table.csv') df['label'] = (df['year'] - 2010) / 5 # .apply(lambda x: np.log(x)) df['filename'] = df['ad_id'].apply(lambda x: str(x) + '.jpg') mobilenet = MobileNetV2(input_shape=(224, 224, 3), include_top=False, pooling='avg') for layer in mobilenet.layers: layer.trainable = False new_input = Input(shape=(224, 224, 3)) x = Lambda(lambda y: (y / 128) - 1)(new_input) x = mobilenet(x) x = Dropout(rate=0.2)(x) x = Dense(256, activation='tanh')(x) x = Dropout(rate=0.2)(x) x = Dense(1)(x) model = Model(input=new_input, output=x) print(model.summary())
import av import numpy as np # linear algebra from keras import backend as K from keras.applications import MobileNetV2, imagenet_utils from PIL import Image, ImageFile from sklearn.preprocessing import LabelEncoder from sklearn.utils.extmath import softmax from tensorflow.keras.applications.mobilenet_v2 import (MobileNetV2, preprocess_input) from tensorflow.keras.layers import (Dense, GlobalAveragePooling2D, GlobalMaxPooling2D, Lambda, Softmax) from tensorflow.keras.models import Model from tensorflow.keras.preprocessing import image model_imagenet = MobileNetV2(weights='imagenet') def process_video(vf): video_dict_list = [] try: container = av.open(vf) stream = container.streams.video[0] stream.codec_context.skip_frame = 'NONKEY' folder, filename = os.path.split(vf) #fn = filename.replace(".mp4","").strip() frames_list = [] frame_times = [] ts_list = [] for frame in container.decode(stream): # try:
from keras.layers import Dense, Flatten from keras.applications import MobileNetV2 from keras import optimizers from keras.preprocessing.image import ImageDataGenerator ##################### # STEP - 2: The Model ##################### # Making the model model = Sequential() # For this model I'm using InceptionResNetV2 # I'll use imagenet weights here also mobile = MobileNetV2(include_top=False, weights="imagenet", input_shape=(128, 128, 3), pooling="max") # Adding the mobile model and configuting the output layer model.add(mobile) model.add(Dense(units=102, activation="softmax")) # Compiling the model model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=2e-5), metrics=['accuracy']) # Printing the summary of the model print(model.summary()) ############################
metrics=['accuracy']) return model config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) BATCH_SIZE = 32 trainGen = HDF5DatasetGenerator("hdf5/train1.hdf5", BATCH_SIZE, classes=5) valGen = HDF5DatasetGenerator("hdf5/val.hdf5", BATCH_SIZE, classes=5) mobilenet = MobileNetV2(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) model = build_model(mobilenet) labels = np_utils.to_categorical(valGen.db["labels"][:-1], 5) multilabels = np.empty(labels.shape, dtype=labels.dtype) multilabels[:, 4] = labels[:, 4] for i in range(3, -1, -1): multilabels[:, i] = np.logical_or(labels[:, i], multilabels[:, i + 1]) labels = multilabels kappa_metrics = Metrics() kappa_metrics.my(valdata=(valGen.db["images"][:-1], labels), name="MobileNetV2") path = os.path.sep.join(["output", "{}.png".format(os.getpid())]) mycallback = TrainingMonitor(path)