# -*- coding: utf-8 -*- """ Created on Tue Nov 5 16:32:16 2019 @author: luket """ from tensorflow.keras.applications.vgg16 import VGG16 model = VGG16(weights='imagenet', include_top=False) import IPython.display as display from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D from tensorflow.keras.preprocessing.image import ImageDataGenerator from PIL import Image import numpy as np import matplotlib.pyplot as plt import pathlib from keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.constraints import max_norm from sklearn.utils.multiclass import unique_labels from sklearn.metrics import classification_report, confusion_matrix #small code chunk to split folders into train/val/test #import split_folders # Split with a ratio. # To only split into training and validation set, set a tuple to `ratio`, i.e, `(.8, .2)`. #split_folders.ratio('C:/Users/luket/Desktop/CS_251_DogProject/root_data/Images/Images', output="output", seed=1337, ratio=(.8, .1, .1)) # default values #create image data generators for training and test sets shift = 0.2 IMAGE_SIZE = 250 BATCH_SIZE = 64
import numpy as np import os import tensorflow as tf from tensorflow.keras.layers import Dense,Embedding,Input,Flatten,GRU from tensorflow.keras import Model from tensorflow.keras.optimizers import RMSprop from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences import csv encoder_pre_model = VGG16(include_top=True, weights='imagenet') encoder_output_layer = encoder_pre_model.get_layer('fc2') encoder_output = encoder_output_layer.output encoder_output = Dense(256, activation=tf.nn.tanh)(encoder_output) encoder_model = Model(encoder_pre_model.input, encoder_output) encoder_model = Model(encoder_pre_model.input, encoder_output) for n in range(len(encoder_model.layers)): encoder_model.layers[n-1].trainable = False encoder_model.summary() image_dir = r'C:\ml\image captioning\31296_39911_bundle_archive\flickr30k_images\flickr30k_images' caption_csv = r'C:\ml\image captioning\31296_39911_bundle_archive\flickr30k_images\results.csv' imgcap = {} captions = [] uni_img = [] uni_cap = [] c=0 d=0
from tensorflow.keras.preprocessing.image import ImageDataGenerator import tensorflow as tf import numpy as np gpus = tf.config.experimental.list_physical_devices(device_type='GPU') cpus = tf.config.experimental.list_physical_devices(device_type='CPU') print(gpus, cpus) tf.config.experimental.set_virtual_device_configuration( gpus[0], [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4096)]) batch_size = 32 model = VGG16(input_shape=(150, 150, 3), include_top=True, weights=None, classes=10) from tensorflow.keras.optimizers import RMSprop model.compile(loss='categorical_crossentropy', optimizer=RMSprop(lr=0.0001), metrics=['acc']) ''' loadModel = "./10/10_model_garbage_vgg16.h5" model = tf.keras.models.load_model(loadModel) ''' # model.summary() base = './10/dataset/' train_datagen = ImageDataGenerator(rescale=1. / 255., rotation_range=40, width_shift_range=0.2,
from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras import models from tensorflow.keras.preprocessing import image from tensorflow.keras.applications.vgg16 import preprocess_input import numpy as np base_model = VGG16(weights='imagenet', include_top=True) print(base_model) ''' result <tensorflow.python.keras.engine.functional.Functional object at 0x000001330636DF48> ''' for i, layer in enumerate(base_model.layers): print(i, layer.name, layer.output_shape) '''result 0 input_1 [(None, 224, 224, 3)] 1 block1_conv1 (None, 224, 224, 64) 2 block1_conv2 (None, 224, 224, 64) 3 block1_pool (None, 112, 112, 64) 4 block2_conv1 (None, 112, 112, 128) 5 block2_conv2 (None, 112, 112, 128) 6 block2_pool (None, 56, 56, 128) 7 block3_conv1 (None, 56, 56, 256) 8 block3_conv2 (None, 56, 56, 256) 9 block3_conv3 (None, 56, 56, 256) 10 block3_pool (None, 28, 28, 256) 11 block4_conv1 (None, 28, 28, 512) 12 block4_conv2 (None, 28, 28, 512) 13 block4_conv3 (None, 28, 28, 512) 14 block4_pool (None, 14, 14, 512)
def scheduler(epoch): if epoch < 10: return 0.001 else: return 0.001 * tf.math.exp(0.1 * (10 - epoch)) callbacks = [ tf.keras.callbacks.EarlyStopping(patience=8, monitor='val_loss'), tf.keras.callbacks.TensorBoard(log_dir='./logs'), tf.keras.callbacks.LearningRateScheduler(scheduler) ] base_model0 = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) base_model1 = VGG19(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) base_model2 = MobileNet(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) base_model3 = InceptionV3(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) base_model4 = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) base_models = [base_model0, base_model1, base_model2, base_model3, base_model4]
required=True, help="Path to the index file") argParser.add_argument("-q", "--query", required=True, help="Path to the query image") argParser.add_argument("-r", "--result_path", required=True, help="Path to the result path") args = vars(argParser.parse_args()) if os.path.isdir("vgg16"): model = keras.models.load_model("vgg16") else: model = VGG16(weights="imagenet", include_top=False) searcher = Searcher(args["index"]) img_path = args["query"] img = image.load_img(img_path, target_size=(244, 244)) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) query_features = model.predict(img_array) features_numpy = np.array(query_features) (dist, img_ids) = searcher.search(features_numpy.flatten(), 10) query_img = cv2.imread(img_path) query_resized = cv2.resize(query_img, (720, 480))
# データのロード X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) #list型をnumpy配列に変換 X_train = np.array(X_train) X_test = np.array(X_test) #正解ラベルをOnne-hot形式に変換 y_train = to_categorical(y_train) y_test = to_categorical(y_test) input_tensor = Input(shape=(150, 150, 1)) vgg16 = VGG16(include_top=False, weights=None, input_tensor=input_tensor, input_shape=(100, 100, 1)) # モデルの定義 model = Sequential() model.add(Flatten(input_shape=vgg16.output_shape[1:])) model.add(Dense(128, activation='relu')) model.add(BatchNormalization()) model.add(Dense(64, activation='relu')) model.add(Dropout(0.25)) model.add(BatchNormalization()) model.add(Dense(7, activation='softmax')) model = Model(inputs=vgg16.input, outputs=model(vgg16.output)) for layer in model.layers[:19]:
from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split( X, Y, test_size=0.2, random_state=42, stratify=Y) x_train, x_val, y_train, y_val = train_test_split( x_train, y_train, test_size=0.2, random_state=42 ) from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.models import Model from tensorflow.keras.layers import Input model = Sequential() model.add(VGG16(weights='imagenet', include_top=False, input_shape=(64,64,3))) for layer in model.layers: layer.trainable = False model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(0.3)) model.add(Dense(29, activation='softmax')) model.add(VGG16(weights='imagenet', include_top=False, input_shape=(64,64,3))) for layer in model.layers: layer.trainable = False model.summary() from keras.optimizers import Adam,RMSprop,Adadelta,Nadam,SGD from keras.callbacks import EarlyStopping, ReduceLROnPlateau,ModelCheckpoint es=EarlyStopping(patience=20, verbose=1, monitor='val_loss',restore_best_weights = True)
myDir ="/content/train/*.png" labels = load_labels(myDir) data = load_data(myDir) Labels = tensorflow.keras.utils.to_categorical(labels,10) # converting the grey scale image to rgb images for transfer learning rgb_batch = np.repeat(data[..., np.newaxis], 3, -1) print(rgb_batch.shape) data.shape """Loading VGG 16 for transfer learning""" from tensorflow.keras.applications.vgg16 import VGG16 vgg_conv = VGG16(weights='imagenet' , include_top = False, input_shape=(32,32,3)) for layers in vgg_conv.layers[:-4]: layers.trainable = False from sklearn.model_selection import train_test_split X_train,X_test,y_train,y_test = train_test_split(rgb_batch,Labels,test_size=0.3,random_state=seed_value) img_x , img_y = 32 , 32 X_train = X_train.reshape(X_train.shape[0] , img_x , img_y , 3) X_test = X_test.reshape(X_test.shape[0] , img_x , img_y , 3) input_shape = (img_x,img_y,1) y_train.shape """CNN model"""
height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest', cval=5) validation_datagen = ImageDataGenerator( rescale = 1./255) training_set=training_datagen.flow(X_train,y_train) test_set=validation_datagen.flow(X_test,y_test) IMAGE_SIZE=[224,224] vgg= VGG16(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False) # don't train existing weights\n", for layer in vgg.layers: layer.trainable = False folders = glob('/content/drive/My Drive/Colab Notebooks/Facial Expressions/*') x = Flatten()(vgg.output) prediction=Dense(len(folders), activation='softmax')(x) model = Model(inputs=vgg.input, outputs=prediction) model.summary() model.compile( loss='categorical_crossentropy', optimizer='adam', metrics='accuracy')
import os import matplotlib.pyplot as plt import numpy as np from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input from tensorflow.keras.layers import Dense, Dropout, Flatten, Input from tensorflow.keras.models import Sequential from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.utils import get_file num_classes = 12 # クラス数 # VGG16 モデルを作成する。 vgg16 = VGG16(include_top=False, weights="imagenet", input_tensor=Input(shape=(224, 224, 3))) vgg16.trainable = False # 重みをフリーズする。 model = Sequential([ vgg16, Flatten(), Dense(500, activation="relu"), Dropout(0.5), Dense(500, activation="relu"), Dropout(0.5), Dense(num_classes, activation="softmax"), ]) model.summary() # コンパイル
data.append(j) data = np.array(data, dtype="float") / 255.0 return data, labels def load_svm_relationship(): file = open('models/SVM_relationships', 'rb') return pickle.load(file) if __name__ == '__main__': trainX, trainY = load_data() base_model = VGG16(weights='imagenet', include_top=False, input_tensor=Input(shape=(300, 300, 3)), input_shape=(300, 300, 3)) features = base_model.predict(trainX, batch_size=32, verbose=1) features = features.reshape((features.shape[0], 512 * 9 * 9)) clf_svm = SVC(kernel='linear', probability=True) clf_svm.fit(features, trainY) testData, testLabels = load_data("test") features = base_model.predict(testData, batch_size=32, verbose=1) features = features.reshape((features.shape[0], 512 * 9 * 9)) y_train_pred = clf_svm.predict(features) print(accuracy_score(testLabels, y_train_pred))
# check if the output directory exists, if not, create it. existing_directory("results") existing_directory("results/deep_features") existing_directory("results/deep_features/" + dataset[ds]) # start time print("[STATUS] start time - {}".format( datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))) start = time.time() # create the pretrained models # check for pretrained weight usage or not # check for top layers to be included or not if model_name == "vgg16": base_model = VGG16(weights=weights) model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc1').output) image_size = (224, 224) elif model_name == "vgg19": base_model = VGG19(weights=weights) model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc1').output) image_size = (224, 224) elif model_name == "resnet50": base_model = ResNet50(weights=weights) model = Model(inputs=base_model.input, outputs=base_model.get_layer('flatten').output) image_size = (224, 224) elif model_name == "inceptionv3": base_model = InceptionV3(include_top=include_top,
import matplotlib.pyplot as plt from tensorflow.keras.layers import Dense, GlobalAveragePooling2D from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.preprocessing import image from tensorflow.keras.applications.vgg16 import preprocess_input from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.models import Model from tensorflow.keras.optimizers import Adam from PIL import Image import warnings warnings.filterwarnings("ignore") image_size = [224,224] data_path = 'Data' conv = VGG16(input_shape= image_size+[3],weights='imagenet',include_top=False) conv.output x = conv.output x = GlobalAveragePooling2D()(x) x = Dense(1024,activation='relu')(x) x = Dense(1024,activation='relu')(x) x = Dense(512, activation='relu')(x) pred = Dense(2,activation='softmax')(x) model = Model(inputs = conv.input,outputs=pred)
num_classes = len(train_generator.class_indices) # save the class indices for use in the predictions np.save('class_indices.npy', train_generator.class_indices) # calculate the training steps nb_train_samples = len(train_generator.filenames) train_steps = int(math.ceil(nb_train_samples / batch_size)) # calculate the validation steps nb_validation_samples = len(validation_generator.filenames) validation_steps = int(math.ceil(nb_validation_samples / batch_size)) # create the base pre-trained model base_model = VGG16(weights='imagenet', include_top=False, input_tensor=Input(shape=(img_width, img_height, 3))) # add a global spatial average pooling layer x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) predictions = Dense(num_classes, activation='softmax')(x) # this is the model we will train model = Model(inputs=base_model.input, outputs=predictions) # first: train only the top layers (which were randomly initialized) # i.e. freeze all convolutional layers for layer in base_model.layers: layer.trainable = False
# example of using a pre-trained model as a classifier from tensorflow.keras.applications.vgg16 import preprocess_input from tensorflow.keras.applications.vgg16 import decode_predictions from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.layers import Dense, Activation, Dropout, Flatten, Conv2D, MaxPooling2D, AveragePooling2D Xtrain, Xtest, ytrain, ytest = train_test_split(res_img2, res_label2, test_size=0.2, random_state=8) vgg_model = VGG16(weights='imagenet', include_top=False, input_shape=(227, 227, 3)) vgg_model.layers vgg_model.summary() len(vgg_model.layers) vgg_model.trainable = False inp = keras.Input(shape=(227, 227, 3)) x = vgg_model(inp) # Convert features of shape `base_model.output_shape[1:]` to vectors #x = keras.layers.GlobalAveragePooling2D()(x) # A Dense classifier with a single unit (binary classification) x = keras.layers.Activation('relu')(x) x = keras.layers.Flatten()(x) x = keras.layers.Dense(1000, input_shape=(7, 7, 512))(x)
total_cropped_images_train = np.array(total_cropped_images_train) # Importing required libraries for construction of model. from tensorflow import keras from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.applications.vgg16 import preprocess_input from tensorflow.keras.models import Model from tensorflow.keras.layers import Flatten, Dense from tensorflow.keras import layers # VGG16 is already trained model. "model1" returns features representations as # a vector of length 8192 for each images. The final shape of features is (N,8192) # where N is the total number of images used for training the model. model = VGG16(include_top = False, input_shape = (128,128,3)) output1 = Flatten()(model.layers[-1].output) model1 = Model(inputs = model.inputs, outputs = output1) model_svm = Model(inputs = model.inputs, outputs = model.layers[-2].output) preprocessed_input = preprocess_input(total_cropped_images_train) ann_features_train = model1.predict(preprocessed_input) ########################################################################################## #svm_features_train = model_svm.predict(preprocessed_input) #svm_features_train = tf.keras.layers.GlobalMaxPool2D()(svm_features_train) #svm_features_train = np.array(svm_features_train) ########################################################################################### # The features representations returnde by the model1 is fed to model 2 which retures two # numbers which are the probabilities of an image being classified as cloudy and clear image.
from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions from tensorflow.keras.preprocessing.image import load_img, img_to_array import os #creating an object for VGG16 model(pre-trained) model = VGG16() for file in os.listdir('sample'): print(file) full_path = 'sample/' + file image = load_img(full_path, target_size=(224, 224)) image = img_to_array(image) image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) image = preprocess_input(image) y_pred = model.predict(image) label = decode_predictions(y_pred, top=2) print(label) print()
IMAGE_SIZE = [200, 200] #getting number of files image_files = glob(train_path + '/*/*.jpg') valid_image_files = glob(valid_path + '/*/*.jpg') #number of classes folders = glob(train_path + '/*') print(folders) plt.imshow(image.load_img(np.random.choice(image_files))) plt.show() #Load the pre-trained model................ ptm = PretrainedModel(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False) ptm.trainable = False #Build the model.................. K = len(folders) x = Flatten()(ptm.output) x = Dense(K, activation='softmax')(x) model = Model(inputs=ptm.input, outputs=x) print(model.summary()) #Create a instance of generator.......... gen = ImageDataGenerator(rotation_range=20,
test_it = datagen.flow_from_directory(test_folder, target_size=(IMG_SIZE, IMG_SIZE), class_mode='categorical', batch_size=batch_size, shuffle=False) filepath = os.path.join(output_folder, modelname + ".hdf5") loss_epoch_file = os.path.join(output_folder, modelname + '.csv') plt_file = os.path.join(output_folder, modelname + '_plot.png') print(filepath) print(loss_epoch_file) modelGo = VGG16(include_top=True, input_shape=(IMG_SIZE, IMG_SIZE, 3), weights=None, classes=4) modelGo.load_weights(filepath) modelGo.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) predict = modelGo.predict_generator(test_it) loss, acc = modelGo.evaluate_generator(test_it) import math tsLbl = [] test_it.reset() count = 0 number_of_examples = len(test_it.filenames) print("number of examples: {0}".format(number_of_examples))
def get_vgg_twoeyes(optimizer='adam', model_type='VGG19', fc1_size=1024, fc2_size=512, fc3_size=256): kern_init = initializers.glorot_normal() img_input_l = Input(shape=(36, 60, 3), name='img_input_L') img_input_r = Input(shape=(36, 60, 3), name='img_input_R') headpose_input = Input(shape=(2, ), name='headpose_input') # create the base pre-trained model if model_type == 'VGG19': base_model_l = VGG19(input_tensor=img_input_l, weights='imagenet', include_top=False) base_model_r = VGG19(input_tensor=img_input_r, weights='imagenet', include_top=False) elif model_type == 'VGG16': base_model_l = VGG16(input_tensor=img_input_l, weights='imagenet', include_top=False) base_model_r = VGG16(input_tensor=img_input_r, weights='imagenet', include_top=False) else: raise Exception('Unknown model type in get_vgg_twoeyes') for layer_L in base_model_l.layers[1:]: layer_L.name = 'layer_L_' + layer_L.name for layer_R in base_model_r.layers[1:]: layer_R.name = 'layer_R_' + layer_R.name # add a global spatial average pooling layer x_l = base_model_l.output x_l = GlobalAveragePooling2D()(x_l) x_r = base_model_r.output x_r = GlobalAveragePooling2D()(x_r) # let's add a fully-connected layer x_l = Dense(fc1_size, kernel_initializer=kern_init)(x_l) x_l = BatchNormalization()(x_l) x_l = Activation('relu')(x_l) x_r = Dense(fc1_size, kernel_initializer=kern_init)(x_r) x_r = BatchNormalization()(x_r) x_r = Activation('relu')(x_r) x = concatenate([x_l, x_r]) x = Dense(fc2_size, kernel_initializer=kern_init)(x) x = concatenate([x, headpose_input]) x = BatchNormalization()(x) x = Activation('relu')(x) x = Dense(fc3_size, activation='relu', kernel_initializer=kern_init)(x) gaze_predictions = Dense(2, kernel_initializer=kern_init, name='pred_gaze')(x) # this is the model we will train model = Model(inputs=[img_input_l, img_input_r, headpose_input], outputs=gaze_predictions) model.compile(optimizer=optimizer, loss=angle_loss, metrics=['accuracy', accuracy_angle]) return model
x = preprocess_input(first_audio) x = np.expand_dims(x, axis=0) first_vect = first_net.predict(x) y = preprocess_input(second_audio) y = np.expand_dims(y, axis=0) second_vect = second_net.predict(y) return first_vect, second_vect data_set, files = get_data_set("dataset") test_len = round(len(data_set)) first_model_full = VGG16() second_model_full = VGG16() first_model = Model(inputs=first_model_full.input, outputs=first_model_full.get_layer('fc2').output) second_model = Model(inputs=second_model_full.input, outputs=second_model_full.get_layer('fc2').output) euclideans = [] for i in range(test_len): for j in range(i + 1, test_len): f1, t1, s1 = spectrogram(data_set[i]) f2, t2, s2 = spectrogram(data_set[j])
def Segnet(pretrained=True, tnb_extractor=True): """#Building the model > Here we first download the VGG16 feature extractor model (and for this purpose we remove the classification block, i.e. the dense layers) > After, we build the Segnet encoder model by adding the particular segnet layers to the original VGG16 feature extractor, so that we can take advantage of the pretrained weights from the imagenet dataset. > Finally, we build the Segnet decoder and merge it to the encoder to form the complete Segnet model. """ if (pretrained): feature_extractor = VGG16(weights='imagenet', include_top=False, input_shape=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH, config.CHANNELS)) feature_extractor.trainable = tnb_extractor else: feature_extractor = VGG16(include_top=False, input_shape=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH, config.CHANNELS)) feature_extractor.trainable = True pool_size = (2, 2) """# Encoder""" model_input = Input(shape=(config.IMAGE_WIDTH, config.IMAGE_HEIGHT, config.CHANNELS)) x = (feature_extractor.get_layer('block1_conv1'))(model_input) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block1_conv2')(x) x = BatchNormalization()(x) x = Activation("relu")(x) pool_1, mask_1 = MaxPoolingWithArgmax2D(pool_size)(x) x = (feature_extractor.get_layer('block2_conv1'))(pool_1) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block2_conv2')(x) x = BatchNormalization()(x) x = Activation("relu")(x) pool_2, mask_2 = MaxPoolingWithArgmax2D(pool_size)(x) x = (feature_extractor.get_layer('block3_conv1'))(pool_2) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block3_conv2')(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block3_conv3')(x) x = BatchNormalization()(x) x = Activation("relu")(x) pool_3, mask_3 = MaxPoolingWithArgmax2D(pool_size)(x) x = (feature_extractor.get_layer('block4_conv1'))(pool_3) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block4_conv2')(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block4_conv3')(x) x = BatchNormalization()(x) x = Activation("relu")(x) pool_4, mask_4 = MaxPoolingWithArgmax2D(pool_size)(x) x = (feature_extractor.get_layer('block5_conv1'))(pool_4) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block5_conv2')(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = feature_extractor.get_layer('block5_conv3')(x) x = BatchNormalization()(x) x = Activation("relu")(x) pool_5, mask_5 = MaxPoolingWithArgmax2D(pool_size)(x) """### Decoder""" unpool_1 = MaxUnpooling2D(pool_size)([pool_5, mask_5]) x = (Conv2D(512, (3, 3), padding="same"))(unpool_1) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(512, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(512, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) unpool_2 = MaxUnpooling2D(pool_size)([x, mask_4]) x = (Conv2D(512, (3, 3), padding="same"))(unpool_2) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(512, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(256, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) unpool_3 = MaxUnpooling2D(pool_size)([x, mask_3]) x = (Conv2D(256, (3, 3), padding="same"))(unpool_3) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(256, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(128, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) unpool_4 = MaxUnpooling2D(pool_size)([x, mask_2]) x = (Conv2D(128, (3, 3), padding="same"))(unpool_4) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(64, (3, 3), padding="same"))(x) x = BatchNormalization()(x) x = Activation("relu")(x) unpool_5 = MaxUnpooling2D(pool_size)([x, mask_1]) x = (Conv2D(64, (3, 3), padding="same"))(unpool_5) x = BatchNormalization()(x) x = Activation("relu")(x) x = (Conv2D(5, (1, 1), padding="valid"))(x) x = BatchNormalization()(x) #x = Reshape((config.IMAGE_WIDTH * config.IMAGE_HEIGHT, config.NUM_CLASSES), input_shape=(config.IMAGE_WIDTH, config.IMAGE_HEIGHT, config.NUM_CLASSES))(x) model_output = Activation('softmax')(x) model = Model(inputs=model_input, outputs=model_output, name="SegNet") model.summary() return model
def unet(input_shape=(320, 320, 3), weights='imagenet', num_cls=32): #加载ImageNet预训练权重 vgg16_model = VGG16(input_shape=input_shape, weights=weights, include_top=False) # 编码过程VGG16经过4次降采样得到 20*20的特征图 block4_pool = vgg16_model.get_layer('block4_pool').output block5_conv1 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block4_pool) block5_conv2 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block5_conv1) block5_drop = Dropout(0.5)(block5_conv2) # 第1次上采样解码,与VGG第3次降采样编码的结果融合得到 40*40的特征图 block6_up = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2))(block5_drop)) block6_merge = Concatenate(axis=3)( [vgg16_model.get_layer('block4_conv3').output, block6_up]) block6_conv1 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_merge) block6_conv2 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv1) block6_conv3 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block6_conv2) # 第2次上采样解码,与VGG第2次降采样编码的结果融合得到 80*80的特征图 block7_up = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2))(block6_conv3)) block7_merge = Concatenate(axis=3)( [vgg16_model.get_layer('block3_conv3').output, block7_up]) block7_conv1 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_merge) block7_conv2 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv1) block7_conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block7_conv2) # 第3次上采样解码,与VGG第1次降采样编码的结果融合得到 160*160的特征图 block8_up = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2))(block7_conv3)) block8_merge = Concatenate(axis=3)( [vgg16_model.get_layer('block2_conv2').output, block8_up]) block8_conv1 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_merge) block8_conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block8_conv1) # 第4次上采样解码,与VGG降采样之前编码的结果融合得到 320*320的特征图 block9_up = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')( UpSampling2D(size=(2, 2))(block8_conv2)) block9_merge = Concatenate(axis=3)( [vgg16_model.get_layer('block1_conv2').output, block9_up]) block9_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_merge) block9_conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv1) block10_conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(block9_conv2) # 将最后的特征图映射到像素分类空间中去,卷积输出通道数为像素类别数 block10_conv2 = Conv2D(num_cls, 1, activation='sigmoid')(block10_conv1) model = Model(inputs=vgg16_model.input, outputs=block10_conv2) return model
load_weights_from_frcnn = False hyper_params = helpers.get_hyper_params(nms_topn=10) VOC_test_data, VOC_info = helpers.get_dataset("voc/2007", "test") labels = helpers.get_labels(VOC_info) # We add 1 class for background hyper_params["total_labels"] = len(labels) + 1 # If you want to use different dataset and don't know max height and width values # You can use calculate_max_height_width method in helpers max_height, max_width = helpers.VOC["max_height"], helpers.VOC["max_width"] VOC_test_data = VOC_test_data.map(lambda x : helpers.preprocessing(x, max_height, max_width)) padded_shapes, padding_values = helpers.get_padded_batch_params() VOC_test_data = VOC_test_data.padded_batch(batch_size, padded_shapes=padded_shapes, padding_values=padding_values) base_model = VGG16(include_top=False) if hyper_params["stride"] == 16: base_model = Sequential(base_model.layers[:-1]) rpn_model = rpn.get_model(base_model, hyper_params) frcnn_model_path = helpers.get_model_path("frcnn", hyper_params["stride"]) rpn_model_path = helpers.get_model_path("rpn", hyper_params["stride"]) model_path = frcnn_model_path if load_weights_from_frcnn else rpn_model_path rpn_model.load_weights(model_path, by_name=True) for image_data in VOC_test_data: img, gt_boxes, gt_labels = image_data input_img, anchors = rpn.get_step_data(image_data, hyper_params, preprocess_input, mode="inference") rpn_bbox_deltas, rpn_labels = rpn_model.predict_on_batch(input_img) # anchors_shape = tf.shape(anchors)
plt.title("model accuracy") plt.ylabel("Accuracy") plt.xlabel("Epoch") plt.legend(["Accuracy","Validation Accuracy","loss","Validation Loss"]) plt.show() ###---vgg16---final----4th method----------- from tensorflow.keras.models import Model from tensorflow.keras.layers import Flatten, Dense, Dropout from tensorflow.keras.applications import VGG16 IMAGE_SIZE = [380, 380] # we will keep the image size as (380,380). You can increase the size for better results. num_classes=6 # loading the weights of VGG16 without the top layer. These weights are trained on Imagenet dataset. vgg = VGG16(input_shape = IMAGE_SIZE + [3], weights = 'imagenet', include_top = False) # input_shape = (64,64,3) as required by VGG # this will exclude the initial layers from training phase as there are already been trained. for layer in vgg.layers: layer.trainable = False x = Flatten()(vgg.output) x = Dense(512, activation = 'relu')(x) # we can add a new fully connected layer but it will increase the execution time. x = Dropout(0.5)(x) x = Dense(num_classes, activation = 'softmax')(x) # adding the output layer with softmax function as this is a multi label classification problem. model_vgg = Model(inputs = vgg.input, outputs = x) model_vgg.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model_vgg.summary()
def step2(): with open('log.txt') as fd: seen = set([x.strip() for x in fd.readlines()]) with open('putToSqlQueue.txt') as fd: files = [fname.strip() for fname in fd.readlines()] files = [ fname for fname in files if fname.lower().endswith('.jpg') or fname.lower().endswith('.png') ] files = [fname for fname in files if not fname in seen] files = [fname for fname in files if not 'MACOSX' in fname] print(len(files)) from tensorflow.keras.applications.vgg16 import VGG16 from tensorflow.keras.preprocessing import image from tensorflow.keras.applications.vgg16 import decode_predictions, preprocess_input from tensorflow.keras.models import Model from tensorflow.compiler import xla #from keras.applications.vgg16 import VGG16 #from keras.preprocessing import image #from keras.applications.vgg16 import decode_predictions, preprocess_input #from keras.models import Model #from tensorflow.compiler import xla import numpy as np import time import os import sys import PIL import json import math import multiprocessing from glob import glob from PIL import Image from io import BytesIO model = VGG16(weights='imagenet', include_top=True) feat_extractor = Model(inputs=model.input, outputs=model.get_layer("fc2").output) def prepImage(img): x = np.array(img.resize((224, 224)).convert('RGB')) x = np.expand_dims(x, axis=0) x = preprocess_input(x) return x logfd = open('log.txt', 'a') print("Azure Blob Storage v" + __version__ + " - Python quickstart sample") # Create the BlobServiceClient object which will be used to create a container client blob_service_client = BlobServiceClient.from_connection_string( connectionString) container_client = blob_service_client.get_container_client("opengameart") print("\nProcessing blobs...") # List the blobs in the container for i, fname in enumerate(files): try: # Create a blob client using the local file name as the name for the blob print(i, "Reading blob", fname) starts = [] starts.append(time.time()) blob_client = blob_service_client.get_blob_client( container=container_name, blob=fname) imgdata = blob_client.download_blob().readall() print(i, "Preparing image", fname) starts.append(time.time()) file_imgdata = BytesIO(imgdata) dt = Image.open(file_imgdata) pimg = prepImage(dt) print(i, "Computing feature vector", fname) starts.append(time.time()) features = feat_extractor.predict(pimg) print(i, "Features", features) print(i, "Uploading feature vector", fname + ".np") starts.append(time.time()) blob_writer = blob_service_client.get_blob_client( container=container_name, blob=fname + ".np") blob_writer.upload_blob(features.flatten().tobytes(), overwrite=True) end = time.time() print(i, ["read", "prep", "feature", "upload"], [end - start for start in starts]) print(i, "Done with", fname) print('') logfd.write(fname + '\n') except Exception as ex: print('Exception:') print(ex) time.sleep(10) logfd.close()
generator = datagen.flow_from_directory(dir_path, batch_size=10, class_mode='categorical', target_size=(150, 150)) return generator train_generator = load_data( '/content/drive/My Drive/Colab Notebooks/Mask/training') validation_generator = load_data( '/content/drive/My Drive/Colab Notebooks/Mask/testing') from tensorflow.keras.applications.vgg16 import VGG16 pretrained_model = VGG16(input_shape=(150, 150, 3), weights='imagenet', include_top=False) pretrained_model.trainable = False pretrained_model.summary() last_layer_output = pretrained_model.get_layer('block5_pool').output x = Flatten()(last_layer_output) x = Dense(512, activation='relu')(x) x = Dense(2, activation='softmax')(x) model = Model(pretrained_model.input, x) model.summary() model.compile(optimizer='adam',
MasterTensor = np.concatenate((MasterTensor, tensor), axis=0) MasterLabels = np.concatenate((MasterLabels, labels), axis=0) print('Processed class ' + str(c)) return MasterTensor[1:, :, :, :], MasterLabels[1:, :] # ============================================================================= # ============================================================================= """ BUILD FINE-TUNED VGG16 MODEL """ # ============================================================================= """Convnet section""" #Setup the convnet and add dense layers for the big tile model conv_base = VGG16(weights='imagenet', include_top=False, input_shape=(TileSize, TileSize, Nbands)) conv_base.summary() model = models.Sequential() model.add(conv_base) model.add(layers.Flatten()) model.add( layers.Dense(512, activation='relu', kernel_regularizer=regularizers.l2(0.001))) model.add(layers.Dropout(0.5)) model.add( layers.Dense(256, activation='relu', kernel_regularizer=regularizers.l2(0.001))) model.add(layers.Dense(8, activation='softmax'))
''' import tensorflow as tf from tensorflow.keras.preprocessing import image from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions from tensorflow.keras import backend as K import numpy as np import matplotlib.pyplot as plt import cv2 tf.compat.v1.disable_eager_execution() model = VGG16( weights='imagenet' ) # C:\Users\BRAIN\.keras\models\vgg16_weights_tf_dim_ordering_tf_kernels.h5 540M img_path = './creative_commons_elephant.jpg' img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) plt.imshow(x / 255.) plt.show() x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) # list return