def test_pipeline(self): """ Pipeline should provide correct function composition """ img_fpaths = glob(os.path.join(_getSampleJPEGDir(), '*.jpg')) xcpt_model = Xception(weights="imagenet") stages = [('spimage', gfac.buildSpImageConverter(SparkMode.RGB_FLOAT32)), ('xception', GraphFunction.fromKeras(xcpt_model))] piped_model = GraphFunction.fromList(stages) for fpath in img_fpaths: target_size = tuple(xcpt_model.input.shape.as_list()[1:-1]) img = load_img(fpath, target_size=target_size) img_arr = np.expand_dims(img_to_array(img), axis=0) img_input = xcpt.preprocess_input(img_arr) preds_ref = xcpt_model.predict(img_input) spimg_input_dict = imageArrayToStruct(img_input).asDict() spimg_input_dict['data'] = bytes(spimg_input_dict['data']) with IsolatedSession() as issn: # Need blank import scope name so that spimg fields match the input names feeds, fetches = issn.importGraphFunction(piped_model, prefix="") feed_dict = dict((tnsr, spimg_input_dict[tfx.op_name(issn.graph, tnsr)]) for tnsr in feeds) preds_tgt = issn.run(fetches[0], feed_dict=feed_dict) # Uncomment the line below to see the graph # tfx.write_visualization_html(issn.graph, # NamedTemporaryFile(prefix="gdef", suffix=".html").name) self.assertTrue(np.all(preds_tgt == preds_ref))
auto_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0) if os.path.exists('dog_single_xception.h5'): model = load_model('dog_single_xception.h5') else: # create the base pre-trained model input_tensor = Input(shape=(299, 299, 3)) base_model = Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None) base_model.layers.pop() base_model.outputs = [base_model.layers[-1].output] base_model.layers[-1].outbound_nodes = [] base_model.output_layers = [base_model.layers[-1]] img1 = Input(shape=(299, 299, 3), name='img_1') feature1 = base_model(img1) # let's add a fully-connected layer category_predict1 = Dense(100, activation='softmax', name='ctg_out_1')(Dropout(0.5)(feature1))
def transfer_learning_model(train_x, train_y, val_x, val_y, test_x, test_y, num_class, epoch, batch_size, model_type, reshape_size, l1_weight, l2_weight): print(train_x.shape) print(type(train_x)) print('\n') print(train_x[0].shape) # change label into one hot train_y = keras.utils.to_categorical(train_y, num_classes=num_class) val_y = keras.utils.to_categorical(val_y, num_classes=num_class) #test_y = keras.utils.to_categorical(test_y, num_classes=num_class) print(test_y) if model_type == 'vgg16': pre_trained = VGG16( weights='imagenet', include_top=False, # True if we want to add Fully Connected Layer at the Last (False) input_shape=reshape_size + (3,) ) pre_trained.trainable = False # False if we want to freeze the weight elif model_type == 'vgg19': pre_trained = VGG19( weights='imagenet', include_top=False, input_shape=reshape_size+ (3,) ) elif model_type == 'resnet101': pre_trained = ResNet101( weights='imagenet', include_top = False input_shape = reshape_size + (3,) ) elif model_type == 'resnet50': pre_trained = ResNet50( weights='imagenet' include_top = False, input_shape = reshape_size + (3,) ) elif model_type == 'xception': pre_trained = Xception( weights='imagenet', include_top=False, input_shape=reshape_size + (3,) ) elif model_type == 'inception_v3': pre_trained = InceptionV3( weights='imagenet', include_top=False, input_shape=reshape_size + (3,) ) elif model_type == 'mobilenet': pre_trained = MobileNet( weights='imagenet', include_top=False, input_shape=reshape_size + (3,) ) #pre_trained.summary() # Add Fine-Tuning Layers finetune_model = models.Sequential() finetune_model.add(pre_trained) if model_type == 'resnet50': pass else: finetune_model.add(layers.Flatten()) finetune_model.add(layers.Dense(num_class*128,# activation='relu', kernel_regularizer=regularizers.l1_l2( l1=l1_weight, l2=l2_weight) )) finetune_model.add(BatchNormalization()) finetune_model.add(Activation('relu')) #finetune_model.add(layers.Dense(num_class*64, activation='relu')) finetune_model.add(layers.Dense(num_class*32,# activation='relu', kernel_regularizer=regularizers.l1_l2( l1=l1_weight, l2=l2_weight) )) finetune_model.add(BatchNormalization()) finetune_model.add(Activation('relu')) #finetune_model.add(layers.Dense(num_class*16, activation='relu')) finetune_model.add(layers.Dense(num_class*8,# activation='relu', kernel_regularizer=regularizers.l1_l2( l1=l1_weight, l2=l2_weight) )) finetune_model.add(BatchNormalization()) finetune_model.add(Activation('relu')) finetune_model.add(layers.Dense(num_class, activation='softmax')) # Final Activation #finetune_model.summary() # Compile finetune_model.compile( loss = 'categorical_crossentropy', optimizer = 'adam', metrics=['acc'] ) history = finetune_model.fit( train_x, train_y, epochs=epoch, batch_size = batch_size, validation_data = (val_x, val_y) ) # Test Performance ''' TODO: Result 해결하는데 이슈가 있음 ### ! ''' y_pred = finetune_model.predict(test_x) #np.argmax y_pred = np.argmax(y_pred, axis=1) print('>> Predicted Results') print(y_pred) #test_y = np.argmax(test_y, axis=1) print('>> Ground Truth') print(test_y) accuracy = accuracy_score(test_y, y_pred) precision, recall, f1_score, _ = precision_recall_fscore_support(test_y, y_pred, average='micro') print(">> Test Performance <<") print('Acc: ', accuracy) print('Precision: ', precision) print('Recall: ', recall) print('F1 Score: ', f1_score)
def merge(classes, epochs, steps_per_epoch, validation_steps, input_shape): # 加载数据 train_batches, valid_batches = load_data(input_shape) input_shape += (3, ) input_layer = Input(shape=input_shape) dense = DenseNet121(include_top=False, pooling='avg', input_shape=input_shape) xception = Xception(include_top=False, pooling='avg', input_shape=input_shape) dense = dense(input_layer) xception = xception(input_layer) # 把top1_model和top2_model连接起来 t = keras.layers.Concatenate(axis=1)([dense, xception]) if classes == 1: print("二元分类") top_model = Dense(units=classes, activation="sigmoid")(t) model = Model(inputs=input_layer, outputs=top_model) asdl = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) model.compile(loss='binary_crossentropy', optimizer=asdl, metrics=['accuracy']) else: print("多分类") top_model = Dense(units=classes, activation="softmax")(t) model = Model(inputs=input_layer, outputs=top_model) asdl = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) model.compile(loss='categorical_crossentropy', optimizer=asdl, metrics=['accuracy']) # 保存模型 out_dir = "weights/" if not os.path.exists(out_dir): os.makedirs(out_dir) filepath = "weights/merge_{epoch:04d}.h5" # 中途训练效果提升, 则将文件保存, 每提升一次, 保存一次 checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=0, save_best_only=True, mode='max', period=2) # 学习率调整 lr_reduce = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=1, min_lr=0.000005, mode="min") # 早停 earlystopping = EarlyStopping(monitor='val_loss', patience=15, verbose=1, mode='min') # 保存训练过程 log_dir = "logs/" if not os.path.exists(log_dir): os.makedirs(log_dir) logfile = "logs/merge.csv" log = keras.callbacks.CSVLogger(logfile, separator=',', append=False) loggraph = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=True) callbacks_list = [checkpoint, lr_reduce, log] # 训练 model.fit_generator(train_batches, steps_per_epoch=steps_per_epoch, validation_data=valid_batches, validation_steps=validation_steps, epochs=epochs, verbose=2, callbacks=callbacks_list, workers=16, max_queue_size=20)
fig, m_axs = plt.subplots(4, 4, figsize=(16, 16)) for (c_x, c_y, c_ax) in zip(t_x, t_y, m_axs.flatten()): c_ax.imshow(c_x[:, :, 0], cmap='bone', vmin=-1.5, vmax=1.5) c_ax.set_title(', '.join([ n_class for n_class, n_score in zip(all_labels, c_y) if n_score > 0.5 ])) c_ax.axis('off') plt.show() from keras.applications.mobilenet import MobileNet from keras.layers import GlobalAveragePooling2D, Dense, Dropout, Flatten from keras.models import Sequential from keras.applications import densenet, Xception, NASNetMobile xception_model = Xception(input_shape=t_x.shape[1:], weights=None, include_top=False) multi_disease_model = Sequential() multi_disease_model.add(xception_model) multi_disease_model.add(GlobalAveragePooling2D()) multi_disease_model.add(Dropout(0.5)) multi_disease_model.add(Dense(512)) multi_disease_model.add(Dropout(0.5)) multi_disease_model.add(Dense(len(all_labels), activation='sigmoid')) multi_disease_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['binary_accuracy', 'mae']) multi_disease_model.summary() from keras.callbacks import ModelCheckpoint, LearningRateScheduler, EarlyStopping, ReduceLROnPlateau
from keras.applications.inception_v3 import preprocess_input from keras.preprocessing.image import img_to_array from keras.preprocessing.image import load_img import numpy as np import argparse import cv2 ################################################################## ## initialize the input image shape (224x224 pixels) along with the pre-processing function # inputShape = (224, 224) # preprocess = imagenet_utils.preprocess_input ## inception, xception 用下面的 inputShape = (299, 299) preprocess = preprocess_input ################################################################## ## loading model model = Xception(weights="imagenet") ################################################################## ## loading image; 尺寸要和上面的一样 image = load_img("/Users/coder352/github/jImage/Dream_Afar/Acanalonia conica planthopper.jpg", target_size=inputShape) image = img_to_array(image) # a NumPy array of shape (inputShape[0], inputShape[1], 3) image = np.expand_dims(image, axis=0) # we need to expand the dimension by making the shape (1, inputShape[0], inputShape[1], 3) image = preprocess(image) # pre-process the image using the appropriate function based on the model that has been loaded (i.e., mean subtraction, scaling, etc.) preds = model.predict(image) P = imagenet_utils.decode_predictions(preds) # loop over the predictions and display the rank-5 predictions + # probabilities to our terminal for (i, (imagenetID, label, prob)) in enumerate(P[0]): print("{}. {}: {:.2f}%".format(i + 1, label, prob * 100))
stratify=y) X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42, stratify=y_train) # print(X_train) # print(y_train) # print(X_test) # print(y_test) ## define the model (preset weights) print('[INFO] defining model...') ## create the pre-trained base model base_model = Xception(include_top=True, weights=None, classes=40) base_model.load_weights( 'frogsumimodels/Xception_species_distort_TF000/Xception.101.0.952.hdf5') base_model.layers.pop() base_model_layers = base_model.output predictions = Dense(len(labeltonumber), activation='softmax')(base_model_layers) ## create the model to train with the correct number of output model = Model(inputs=base_model.input, outputs=predictions) ## print a summary of the model print(model.summary()) ## values from Olafenwa and Olafenva - 2018 and ## https://machinelearningmastery.com/evaluate-performance-deep-learning-models-keras/
import keras from keras.applications import Xception from keras.layers import Dense, Flatten, Dropout from keras.optimizers import RMSprop from keras.models import Sequential from keras.preprocessing.image import ImageDataGenerator base_dir = "D:/dataset/images/kaggle/" train_dir = os.path.join(base_dir, "train") test_dir = os.path.join(base_dir, 'test') validation_dir = os.path.join(base_dir, 'validation') num_classes = 12 import matplotlib.pyplot as plt conv_base = Xception(include_top=False, weights='imagenet', input_shape=(71, 71, 3)) print(conv_base.summary()) datagen = ImageDataGenerator(rescale=1. / 255, rotation_range=0.2, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') train_gen = datagen.flow_from_directory(train_dir, target_size=(71, 71), batch_size=20,
train_dir = os.path.join(base_dir, 'train') validation_dir = os.path.join(base_dir, 'validation') test_dir = os.path.join(base_dir, 'test') train_cats_dir = os.path.join(train_dir, 'cats') train_dogs_dir = os.path.join(train_dir, 'dogs') validation_cats_dir = os.path.join(validation_dir, 'cats') validation_dogs_dir = os.path.join(validation_dir, 'dogs') test_cats_dir = os.path.join(test_dir, 'cats') test_dogs_dir = os.path.join(test_dir, 'dogs') xc_base = Xception(input_shape=(150, 150, 3), weights='imagenet', include_top=False) xc_base.trainable = False model = models.Sequential() # model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(150, 150, 3))) # model.add(layers.MaxPooling2D((2, 2))) # model.add(layers.Conv2D(64, (3, 3), activation='relu')) # model.add(layers.MaxPooling2D((2, 2))) # model.add(layers.Conv2D(128, (3, 3), activation='relu')) # model.add(layers.MaxPooling2D((2, 2))) # model.add(layers.Conv2D(128, (3, 3), activation='relu')) # model.add(layers.MaxPooling2D((2, 2))) model.add(xc_base) model.add(layers.Flatten())
def xception(): model = Xception(weights="imagenet") graph = tf.get_default_graph() return model, graph
val_datagen = ImageDataGenerator(rescale=1. / 255) val_generator = val_datagen.flow_from_directory('./data/val/', target_size=(299, 299), batch_size=BATCH_SIZE, class_mode='categorical', shuffle=True) # pretrain dense layer # to avoid large gradient to destroy the pretrained model # build model tensorboard = TensorBoard('./log/new_xception') basic_model = Xception(input_shape=(299, 299, 3), include_top=False, weights='imagenet', pooling='avg') for layer in basic_model.layers: layer.trainable = False # build top x = basic_model.output x = Dropout(0.5)(x) pred = Dense(12, activation='softmax')(x) model = Model(inputs=basic_model.input, outputs=pred) model.compile(optimizer=optimizers.RMSprop(1e-3), loss='categorical_crossentropy', metrics=['accuracy'])
from preprocess import train, val, train_steps, val_steps from keras.applications import Xception from keras import layers, models from keras import callbacks, optimizers # Uneven class distribution class_weight = { train.class_indices['normal']: 1, train.class_indices['glaucoma']: 1.86 } # Using pretrained Xception Net as Convolutional feature extractor conv_base = Xception(include_top=False, weights='imagenet', input_shape=(299, 299, 3)) model = models.Sequential() model.add(conv_base) model.add(layers.Flatten()) model.add(layers.Dense(256, activation='relu')) model.add(layers.Dropout(0.5)) model.add(layers.Dense(1, activation='sigmoid')) model.compile(optimizers.RMSprop(1e-5), 'binary_crossentropy', metrics=['accuracy']) model.load_weights('/model/best_weights.h5') conv_base.trainable = True for layer in conv_base.layers: if layer.name != 'block14_sepconv2': layer.trainable = False
# print(y_test) X_test_mean = X_test - mean if modus == 'save': ## for tests use data_{}_{}.test.npz ## /home/stine/repositories # filename = 'npz/img_attr_{}_{}.npz'.format(mode, resize) # img_attr = load_img_attr_data(filename) ## creates model used for training and loads weights print('[INFO] create model and load weights ...') weights = path_weights + weightfile # with tf.device('/cpu:0'): model = Xception(include_top=True, weights=weights, classes=len(labeltonumber)) # model = multi_gpu_model(model, gpus=2) # model.load_weights(weights) ## changes last layer activation from softmax to linear to improve attribution results print('[INFO] change activations of last layer to linear ...') layer_idx = utils.find_layer_idx(model, 'predictions') model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) print(model.summary()) print(model.input) print('[INFO] calculate cam ...')
def create_model(): backbone = Xception(input_shape=(400, 400, 3), weights='imagenet', include_top=False) input_ = backbone.input conv4 = backbone.layers[121].output #(None, 25, 25, 1024) conv4 = LeakyReLU(alpha=0.1)(conv4) pool4 = MaxPooling2D((2, 2))(conv4) #(None, 12, 12, 1024) pool4 = Dropout(.5)(pool4) decoder4 = decoder_block(pool4, 512, (3, 3)) #(None, 12, 12, 512) deconv4 = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding="valid")(decoder4) #(None, 25, 25, 256) conv4 = decoder_block(conv4, 256, activation=False) #(None, 25, 25, 256) uconv4 = concatenate([deconv4, conv4]) #(None, 25, 25, 512) uconv4 = LeakyReLU(alpha=0.1)(uconv4) uconv4 = Dropout(.5)(uconv4) decoder3 = decoder_block(uconv4, 256, (3, 3)) #(None, 25, 25, 256) deconv3 = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding="same")(decoder3) #(None, 50, 50, 128) conv3 = backbone.layers[31].output #(None, 50, 50, 728) conv3 = LeakyReLU(alpha=0.1)(conv3) conv3 = decoder_block(conv3, 128, activation=False) #(None, 50, 50, 128) uconv3 = concatenate([deconv3, conv3]) #(None, 50, 50, 256) uconv3 = Dropout(.5)(uconv3) uconv3 = LeakyReLU(alpha=0.1)(uconv3) decoder2 = decoder_block(uconv3, 128, (3, 3)) #(None, 50, 50, 128) deconv2 = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="same")(decoder2) #(None, 100, 100, 64) conv2 = backbone.layers[21].output #(None, 99, 99, 256) conv2 = LeakyReLU(alpha=0.1)(conv2) conv2 = ZeroPadding2D(((1, 0), (1, 0)))(conv2) #(None, 100, 100, 256) conv2 = decoder_block(conv2, 64, activation=False) #(None, 100, 100, 64) uconv2 = concatenate([deconv2, conv2]) #(None, 100, 100, 128) uconv2 = Dropout(.1)(uconv2) uconv2 = LeakyReLU(alpha=0.1)(uconv2) decoder1 = decoder_block(uconv2, 64, (3, 3)) #(None, 100, 100, 64) deconv1 = Conv2DTranspose(32, (3, 3), strides=(2, 2), padding="same")(decoder1) #(None, 200, 200, 32) conv1 = backbone.layers[11].output #(None, 197, 197, 128) conv1 = LeakyReLU(alpha=0.1)(conv1) conv1 = ZeroPadding2D(((3, 0), (3, 0)))(conv1) #(None, 200, 200, 128) conv1 = decoder_block(conv1, 32, activation=False) #(None, 200, 200, 32) uconv1 = concatenate([deconv1, conv1]) #(None, 200, 200, 64) uconv1 = Dropout(.1)(uconv1) uconv1 = LeakyReLU(alpha=0.1)(uconv1) decoder0 = decoder_block(uconv1, 32, (3, 3)) #(None, 200, 200, 32) deconv0 = Conv2DTranspose(16, (3, 3), strides=(2, 2), padding="same")(decoder0) #(None, 400, 400, 16) conv0 = decoder_block(input_, 16, activation=False) #(None, 400, 400, 16) uconv0 = concatenate([deconv0, conv0]) #(None, 400, 400, 32) uconv0 = Dropout(.4)(uconv0) uconv0 = LeakyReLU(alpha=0.1)(uconv0) final_decoder = decoder_block(uconv0, 16, (3, 3)) #(None, 400, 400, 16) final_decoder = Dropout(.25)(final_decoder) output_ = Conv2D(1, (1, 1), padding="same", activation="sigmoid")(final_decoder) #(None, 400, 400, 1) model = Model(inputs=input_, outputs=output_) model.name = 'ures_xception' return model
return img imgs_dir = "/home/alex/Downloads/ILSVRC/Data/DET/test/" vecs_path = 'imagenet_vectors.npy' img_paths = sorted(glob('%s/*.JPEG' % imgs_dir)) fp_paths = open('imagenet_paths.txt', 'w') dim = 224 batch_size = 500 imgs_batch = np.zeros((batch_size, dim, dim, 3)) # Instantiate model and chop off some layers. vector_layer = "avg_pool" m1 = Xception() m2 = Model(inputs=m1.input, outputs=m1.get_layer(vector_layer).output) vecs = np.zeros((len(img_paths), m2.output_shape[-1])) for i in range(0, len(img_paths), batch_size): for j in range(batch_size): imgs_batch[j] = get_img(img_paths[i + j], dim) imgs_batch = preprocess_input(imgs_batch, mode='tf') prds_batch = m2.predict(imgs_batch) vecs[i:i + batch_size] = prds_batch fp_paths.write('\n'.join(img_paths[i:i + batch_size]) + '\n') print('%d-%d %.3lf %.3lf %.3lf' %
from keras.applications import VGG16, VGG19 from keras.models import Sequential from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, BatchNormalization, Activation from keras.applications import MobileNet, MobileNetV2, DenseNet121, DenseNet169, DenseNet201 from keras.applications import NASNetLarge, NASNetMobile from keras.applications import Xception, ResNet101 from keras.optimizers import Adam from keras.applications import ResNet101V2, ResNet152, ResNet152V2, ResNet50, ResNet50V2, InceptionV3, InceptionResNetV2 model = VGG19() model = Xception() model = ResNet101() model = ResNet101V2() model = ResNet152() model = ResNet152V2() model = ResNet50() model = ResNet50V2() model = InceptionV3() model = InceptionResNetV2() model = MobileNet() model = MobileNetV2() model = DenseNet121() model = DenseNet169() model = DenseNet201() model = NASNetLarge() model = NASNetMobile() vgg16 = VGG16( weights=None, include_top=False, classes=10,
print('****************') classes_name = [0 for i in range(NUM_CLASSES)] for cls, idx in train_batches.class_indices.items(): print('Class #{} = {}'.format(idx, cls)) classes_name[idx] = cls print(classes_name) print('****************') # build our classifier model based on pre-trained InceptionResNetV2: # 1. we don't include the top (fully connected) layers of InceptionResNetV2 # 2. we add a DropOut layer followed by a Dense (fully connected) # layer which generates softmax class score for each class # 3. we compile the final model using an Adam optimizer, with a # low learning rate (since we are 'fine-tuning') base_model = Xception(include_top=False, weights='imagenet', input_tensor=None, input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)) for layer in base_model.layers: layer.trainable = True # add a global spatial average pooling layer x = base_model.output x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dropout(0.5)(x) # and a logistic layer -- let's say we have 200 classes predictions = Dense(NUM_CLASSES, activation='softmax')(x) # this is the model we will train model = Model(inputs=base_model.input, outputs=predictions) print(len(model.layers))
deep_learning_feature_file_name = 'feature_data/' + dataset_name + '_' + model_name + '_image_tag_feature.npy' if model_name == 'VGG16': model = VGG16(weights='imagenet', include_top=True) im_size = 224 elif model_name == 'VGG19': model = VGG19(weights='imagenet', include_top=True) im_size = 224 elif model_name == 'ResNet50': model = ResNet50(weights='imagenet', include_top=True) im_size = 224 elif model_name == 'InceptionV3': model = InceptionV3(weights='imagenet', include_top=True) im_size = 299 elif model_name == 'Xception': model = Xception(weights='imagenet', include_top=True) im_size = 299 #print(model.summary()) for im in os.listdir(im_path): print(im) try: img = Image.load_img(im_path + im, target_size=(im_size, im_size)) except: print(im_path + im) continue x = Image.img_to_array(img) x = np.expand_dims(x, axis=0) # im_last_layer_feature = image_feature_extraction(x, model)
def xception(classes, epochs, steps_per_epoch, validation_steps, input_shape): # 加载数据 train_batches, valid_batches = load_data(input_shape) input_shape += (3, ) base_model = Xception(include_top=False, input_shape=input_shape) x = base_model.output x = GlobalAveragePooling2D()( x) # GlobalAveragePooling2D 将 MxNxC 的张量转换成 1xC 张量,C是通道数 x = Dropout(0.5)(x) if classes == 1: print("二元分类") outputs = Dense(classes, activation='sigmoid')(x) model = Model(base_model.inputs, outputs) model.compile(optimizer=keras.optimizers.Adam(lr=0.0001), metrics=['accuracy'], loss='binary_crossentropy') else: print("多分类") outputs = Dense(classes, activation='softmax')(x) model = Model(base_model.inputs, outputs) model.compile(optimizer=keras.optimizers.Adam(lr=0.0001), metrics=['accuracy'], loss='categorical_crossentropy') # 保存模型 out_dir = "../weights/" if not os.path.exists(out_dir): os.makedirs(out_dir) filepath = "../weights/xception_{epoch:04d}.h5" # 中途训练效果提升, 则将文件保存, 每提升一次, 保存一次 checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=0, save_best_only=True, mode='max') # 学习率调整 lr_reduce = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, verbose=1, min_lr=0.00000001, mode="min") # 早停 earlystopping = EarlyStopping(monitor='val_loss', patience=15, verbose=1, mode='min') # 保存训练过程 log_dir = "../logs/" if not os.path.exists(log_dir): os.makedirs(log_dir) logfile = "../logs/xception.csv" log = keras.callbacks.CSVLogger(logfile, separator=',', append=False) loggraph = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=True) callbacks_list = [checkpoint, lr_reduce, log, earlystopping] # 训练 model.fit_generator(train_batches, steps_per_epoch=steps_per_epoch, validation_data=valid_batches, validation_steps=validation_steps, epochs=epochs, verbose=2, callbacks=callbacks_list, workers=16, max_queue_size=20)
batch_size=10, shuffle=False, class_mode="categorical", target_size=(299, 299)) test_generator = test_datagen.flow_from_dataframe( dataframe=df_test, directory=img_path, x_col="Überschrift der Spalte mit den Dateinamen", y_col="Überschrift der Spalte mit den Schadensklassen", classes=['Klasse 1', 'Klasse 2', 'Klasse 3', 'Klasse 4', 'Klasse 5'], batch_size=9, shuffle=False, class_mode='categorical', target_size=(299, 299)) inp = layers.Input([299, 299, 3]) model_1 = Xception(weights='imagenet', include_top=False, input_tensor=inp) model_1.trainable = True set_trainable = False for layer in model_1.layers: if layer.name == 'block14_sepconv2': set_trainable = True if set_trainable: layer.trainable = True else: layer.trainable = False x = layers.Flatten()(model_1.output) x = layers.Dropout(0.3)(x) x = layers.Dense(256, activation='relu')(x)
from keras.layers import Conv2D from keras.layers import SeparableConv2D from keras.layers import MaxPooling2D from keras.layers import GlobalAveragePooling2D from keras.layers import GlobalMaxPooling2D from keras.engine.topology import get_source_inputs from keras.utils.data_utils import get_file from keras import backend as K from keras.applications.imagenet_utils import decode_predictions from keras.applications.imagenet_utils import _obtain_input_shape from keras.applications import Xception from keras.applications.xception import preprocess_input TF_WEIGHTS_PATH = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.4/xception_weights_tf_dim_ordering_tf_kernels.h5' TF_WEIGHTS_PATH_NO_TOP = 'https://github.com/fchollet/deep-learning-models/releases/download/v0.4/xception_weights_tf_dim_ordering_tf_kernels_notop.h5' if __name__ == '__main__': model = Xception(include_top=True, weights='imagenet') img_path = 'data\\dogscats\\train\\cats\\cat.10013.jpg' img = image.load_img(img_path, target_size=(299, 299)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) print('Input image shape:', x.shape) preds = model.predict(x) print(np.argmax(preds)) print('Predicted:', decode_predictions(preds, 1)) # ('n02123394', 'Persian_cat', 0.91428012)
batch_size=batch_size, seed=42 # set seed for reproducability ) # Validation image generator validation_generator = test_image_gen.flow_from_directory( validate_dir, target_size=(Image_width, Image_height), batch_size=batch_size, seed=42 # set seed for reproducability ) # Load the INception V3 model and load it with it's pre-trained weights. But exclude the final # Fully Connected Layer Xception_base_model = Xception( weights='imagenet', include_top=False) # include_top=False excludes final FC layer print('Xception base model without last FC loaded') # Define the layers in the new classification prediction x = Xception_base_model.output x = GlobalAveragePooling2D()(x) x = Dense(Number_FC_Neurons, activation='relu')(x) # new FC layer, random init predictions = Dense(num_classes, activation='softmax')(x) # new softmax layer # Define trainable model which links input from the Xception base model to the new classification prediction layers model = Model(inputs=Xception_base_model.input, outputs=predictions) # Print model structure diagram print(model.summary())
def extract_features(input_dir, output_dir, model_type='inceptionv3', batch_size=32): """ Extracts features from a CNN trained on ImageNet classification from all videos in a directory. Args: input_dir (str): Input directory of videos to extract from. output_dir (str): Directory where features should be stored. model_type (str): Model type to use. batch_size (int): Batch size to use when processing. """ input_dir = os.path.expanduser(input_dir) output_dir = os.path.expanduser(output_dir) if not os.path.isdir(input_dir): sys.stderr.write("Input directory '%s' does not exist!\n" % input_dir) sys.exit(1) # Load desired ImageNet model # Note: import Keras only when needed so we don't waste time revving up # Theano/TensorFlow needlessly in case of an error model = None input_shape = (224, 224) if model_type.lower() == 'inceptionv3': from keras.applications import InceptionV3 model = InceptionV3(include_top=True, weights='imagenet') elif model_type.lower() == 'xception': from keras.applications import Xception model = Xception(include_top=True, weights='imagenet') elif model_type.lower() == 'resnet50': from keras.applications import ResNet50 model = ResNet50(include_top=True, weights='imagenet') elif model_type.lower() == 'vgg16': from keras.applications import VGG16 model = VGG16(include_top=True, weights='imagenet') elif model_type.lower() == 'vgg19': from keras.applications import VGG19 model = VGG19(include_top=True, weights='imagenet') else: sys.stderr.write("'%s' is not a valid ImageNet model.\n" % model_type) sys.exit(1) if model_type.lower() == 'inceptionv3' or model_type.lower() == 'xception': shape = (299, 299) # Get outputs of model from layer just before softmax predictions from keras.models import Model model = Model(model.inputs, output=model.layers[-2].output) # Create output directories visual_dir = os.path.join(output_dir, 'visual') # RGB features #motion_dir = os.path.join(output_dir, 'motion') # Spatiotemporal features #opflow_dir = os.path.join(output_dir, 'opflow') # Optical flow features for directory in [visual_dir]:#, motion_dir, opflow_dir]: if not os.path.exists(directory): os.makedirs(directory) # Find all videos that need to have features extracted def is_video(x): return x.endswith('.mp4') or x.endswith('.avi') or x.endswith('.mov') vis_existing = [x.split('.')[0] for x in os.listdir(visual_dir)] #mot_existing = [os.path.splitext(x)[0] for x in os.listdir(motion_dir)] #flo_existing = [os.path.splitext(x)[0] for x in os.listdir(opflow_dir)] video_filenames = [x for x in sorted(os.listdir(input_dir)) if is_video(x) and os.path.splitext(x)[0] not in vis_existing] # Go through each video and extract features from keras.applications.imagenet_utils import preprocess_input for video_filename in tqdm(video_filenames): # Open video clip for reading try: clip = VideoFileClip( os.path.join(input_dir, video_filename) ) except Exception as e: sys.stderr.write("Unable to read '%s'. Skipping...\n" % video_filename) sys.stderr.write("Exception: {}\n".format(e)) continue # Sample frames at 1fps fps = int( np.round(clip.fps) ) frames = [scipy.misc.imresize(crop_center(x.astype(np.float32)), shape) for idx, x in enumerate(clip.iter_frames()) if idx % fps == fps//2] n_frames = len(frames) frames_arr = np.empty((n_frames,)+shape+(3,), dtype=np.float32) for idx, frame in enumerate(frames): frames_arr[idx,:,:,:] = frame frames_arr = preprocess_input(frames_arr) features = model.predict(frames_arr, batch_size=batch_size) name, _ = os.path.splitext(video_filename) feat_filepath = os.path.join(visual_dir, name+'.npy') with open(feat_filepath, 'wb') as f: np.save(f, features)
epochs = 20 # number of iteration the algorithm gets trained. augmentation_strength = 0.2 GPUS = True # Important to utilize CPUs even when training on multi-GPU instances as the CPUs can be a bottle neck when feeding to the GPUs CPUS = 16 train_folder = 'data/train' validation_folder = 'data/test' save_class_names(train_folder, project_name) target_size = (299, 299) input_size = target_size + (3,) base_model = Xception(weights='imagenet', include_top=False, input_shape=input_size) model = update_base_model(base_model) # Initialize a dictionary with the layer name and corresponding learning rate ratio layer_mult = create_learn_rate_dict(model) # Initialize optimizer and compile the model adam_with_lr_multipliers = Adam_lr_mult(multipliers=layer_mult) model.compile(optimizer=adam_with_lr_multipliers, loss='categorical_crossentropy', metrics=['accuracy']) if GPUS: # Intialize a multi-GPU model utilizing keras.utils.multi_gpu_model and then overriding the save and load models so that we can save in a format that the model can be read as a serial model model = ModelMGPU(model)