input_shape=(target_size, target_size, 3)),
"vgg19":
VGG19(weights="imagenet",
include_top=False,
input_shape=(target_size, target_size, 3)),
"inceptionv3":
InceptionV3(weights="imagenet",
include_top=False,
input_shape=(target_size, target_size, 3)),
"xception":
Xception(weights="imagenet",
include_top=False,
input_shape=(target_size, target_size, 3)),
"resnet50":
ResNet50(weights="imagenet",
include_top=False,
input_shape=(target_size, target_size, 3)),
}
freezing_layers = {
"vgg16": ("block5_conv1", 15, 16),
"vgg19": ("block5_conv1", 17, 16),
"inceptionv3": ("conv2d_65", 197, 32),
"xception": ("add_10", 105, 32),
"resnet50": ("add_8", 89, 32),
}
for i in range(3):
for n, m in models.items():
try:
# if not n in ["inceptionv3"]:
# print("pass")
# continue
def make_plain_model(num_classes):
model = ResNet50(classes=num_classes, weights=None)
model.compile(optimizer='sgd', loss='categorical_crossentropy')
return model
import os
os.environ["CUDA_VISIBLE_DEVICES"] = ""
from keras.applications import ResNet50
import cv2
from PIL import Image
import numpy as np
from math import sqrt
model = ResNet50(include_top=False, weights='imagenet', pooling='avg')
def dot_product(v1, v2):
return sum(a * b for a, b in zip(v1, v2))
def magnitude(vector):
return sqrt(dot_product(vector, vector))
def similarity(v1, v2):
"""
计算余弦相似度
"""
return dot_product(v1, v2) / (magnitude(v1) * magnitude(v2) + .00000000001)
def template_select(image1, image2):
image1 = np.expand_dims(np.array(image1.convert('RGB')), axis=0)
image2 = np.expand_dims(np.array(image2.convert('RGB')), axis=0)
def SDPN(summary=False):
"""
Create and return Semantic-aware Dense Prediction Network.
Parameters
----------
summary : bool
If True, network summary is printed to stout.
Returns
-------
model : keras Model
Model of SDPN
"""
input_coords = Input(shape=(4, ))
input_crop = Input(shape=(224, 224, 3))
# extract feature from image crop
resnet = ResNet50(include_top=False, weights='imagenet')
for layer in resnet.layers: # set resnet as non-trainable
layer.trainable = False
crop_encoded = resnet(input_crop) # shape of `crop_encoded` is 2018x1x1
crop_encoded = Reshape(target_shape=(2048, ))(crop_encoded)
# encode input coordinates
h = Dense(256)(input_coords)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(256, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(256, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
# merge feature vectors from crop and coords
merged = concatenate([crop_encoded, h])
# decoding into output distance
h = Dense(1024)(merged)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(512, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(256, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(128, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
h = Dense(64, kernel_constraint=maxnorm(3))(h)
h = ELU()(h)
h = Dropout(rate=0.4)(h)
output_dist = Dense(1, activation='relu')(h) #relu to output distance >= 0
model = Model(inputs=[input_coords, input_crop], outputs=output_dist)
if summary:
model.summary()
return model
def load_model():
global model
print(" * Loading pre-trained model...")
model = ResNet50(weights="imagenet")
print(" * Loading end")
from flask_ngrok import run_with_ngrok
import cv2
from keras.models import load_model
import numpy as np
from keras.applications import ResNet50
from keras.optimizers import Adam
from keras.layers import Dense, Flatten, Input, Convolution2D, Dropout, LSTM, TimeDistributed, Embedding, Bidirectional, Activation, RepeatVector, Concatenate
from keras.models import Sequential, Model
from keras.utils import np_utils
from keras.preprocessing import image, sequence
import cv2
from keras.preprocessing.sequence import pad_sequences
from tqdm import tqdm
resnet = ResNet50(include_top=False,
weights='imagenet',
input_shape=(224, 224, 3),
pooling='avg')
print("=" * 150)
print("RESNET MODEL LOADED")
vocab = np.load('vocab.npy', allow_pickle=True)
vocab = vocab.item()
inv_vocab = {v: k for k, v in vocab.items()}
print("+" * 50)
print("vocabulary loaded")
embedding_size = 128
cond_classes = 5 + 4 + 9
#Trained top
top_model = Sequential()
top_model.add(Flatten(input_shape=(1, 2, 2048)))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.50))
top_model.add(Dense(cond_classes, activation='sigmoid'))
top_model.add(Lambda(split_mammals, name='cond_layer'))
top_model.add(Lambda(convert_cond_probabilities))
top_model.load_weights(os.path.join(config['weight_path'],
'resnet_bottleneck_weights.h5'),
by_name=False)
conv_base = ResNet50(include_top=False,
weights='imagenet',
input_shape=(270, 480, 3)) #Pretrained base
conv_base.trainable = True #Unfreeze convolutional base to finetune
model = Sequential()
model.add(conv_base)
model.add(top_model)
#Select trainable layers
layer_names = []
for layer in conv_base.layers:
layer_names.append(layer.name)
set_trainable = False
for layer in conv_base.layers:
if layer.name == 'block5_conv1':
trainY = data['arr_1']
testX = data['arr_2']
testY = data['arr_3']
print('loaded data')
# initialize an our data augmenter as an "empty" image data generator
#aug = ImageDataGenerator()
# In[2]:
img_height, img_width = 128, 128
num_classes = 2
input_shape = (img_height, img_width, 3)
base_model = ResNet50(
weights='imagenet',
include_top=False,
input_shape=(img_height, img_width,
3)) #imports the mobilenet model and discards the
# Freeze the layers except the last 4 layers
for layer in base_model.layers[:-3]:
layer.trainable = False
# Check the trainable status of the individual layers
#for layer in base_model.layers:
# print(layer, layer.trainable)
# ## Added three dense layers and the last layer is having 7 classes
# In[12]:
from keras.applications import ResNet50 model = ResNet50(include_top=True, weights="imagenet") print(model.summary())
def empty_resnet():
K.set_image_data_format('channels_last')
base_model = ResNet50(weights=None,include_top=False,input_shape=(224,224,3))
features = GlobalAveragePooling2D()(base_model.output)
model = Model(inputs=base_model.input, outputs=features)
return model
from keras.optimizers import Adam
# 1. data
(x_train, y_train),(x_test, y_test) = cifar10.load_data()
print(f"x_train.shape : {x_train.shape}")
print(f"x_test.shape : {x_test.shape}")
print(f"y_train.shape : {y_train.shape}")
print(f"y_test.shape : {y_test.shape}")
x_train = x_train.reshape(50000,32,32,3).astype('float32')/255.0
x_test = x_test.reshape(10000,32,32,3).astype('float32')/255.0
# 2. model
# vgg16 = ResNet152V2(weights='imagenet' , include_top=False, input_shape=(32,32,3))
vgg16 = ResNet50(weights='imagenet' , include_top=False,input_shape=(32,32,3))
vgg16.summary()
# vgg16 = Dense(10,activation='softmax')(vgg16)
model = Sequential()
model.add(vgg16)
model.add(Flatten())
model.add(Dense(256))
# model.add(BatchNormalization())
model.add(Dropout(0.1))
model.add(Activation('relu'))
def on_epoch_end(self, epoch, logs={}):
x, y = self.test_data
loss, acc = self.model.evaluate(x, y, verbose=0)
print('\nTesting loss: {}, acc: {}\n'.format(loss, acc))
IMAGE_SIZE = [
224, 224
] # we will keep the image size as (64,64). You can increase the size for better results.
# 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
#base_model = InceptionResNetV2(input_shape = IMAGE_SIZE + [3],include_top=False )
base_model = ResNet50(input_shape=IMAGE_SIZE + [3], include_top=False)
# def save_array(fname, arr):
# c=bcolz.carray(arr, rootdir=fname, mode='w')
# c.flush()
# def load_array(fname):
# return bcolz.open(fname)[:]
#path = "/home/ws2/Documents/cropdata/"
path = "/home/ws2/Documents/kinectdata/seg1/"
#path ="/home/ws2/Documents/kinectdata/seg2/"
#path ="/home/ws2/Documents/kinectdata/seg3/"
#path ="/home/ws2/Documents/kinectdata/seg4/"
# path = "data/dogscats/"
model_path = path + 'models/'
def load_model():
global model
model = ResNet50(weights="imagenet")
from keras import applications from keras.applications import Xception from keras.applications import InceptionV3,ResNet50 from keras.layers import Input a = Input(shape=(300,200,3)) print(type(a)) net = ResNet50(input_tensor=a) from keras.utils import plot_model plot_model(net,show_shapes=True,to_file='xception.png') # print(dir(applications))
# initialize the validation/testing data augmentation object (which
# we'll be adding mean subtraction to)
valAug = ImageDataGenerator()
# define the ImageNet mean subtraction (in RGB order) and set the
# the mean subtraction value for each of the data augmentation
# objects
mean = np.array([123.68, 116.779, 103.939], dtype="float32")
trainAug.mean = mean
valAug.mean = mean
# load the ResNet-50 network, ensuring the head FC layer sets are left
# off
baseModel = ResNet50(weights="imagenet",
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
# construct the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(512, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(len(lb.classes_), activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# from tensorflow.python.keras.applications.vgg16 import VGG16 from keras.applications import ResNet50 # conv_base = Xception(weights='imagenet', include_top=False, # input_shape=(150,150,3)) conv_base = ResNet50() # (224, 224, 3) conv_base.summary() # conv_base.summary() from keras import models, layers model = models.Sequential() model.add(conv_base) # model.add(layers.Flatten()) model.add(layers.Dense(256, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) model.summary()
target_size=(trgt_sz, trgt_sz),
batch_size=batch_size,
class_mode='binary') # changed from "categorical" to "binary"
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
shuffle=False,
target_size=(trgt_sz, trgt_sz),
batch_size=batch_size,
class_mode='binary') # changed from "categorical" to "binary"
#######################################################################
## Model ##############################################################
#######################################################################
base_model = ResNet50(weights='imagenet', include_top=False)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dropout(0.2)(x) # new dropout layer
x = Dense(1024, activation='relu')(x)
predictions = Dense(1, activation='sigmoid')(
x) # changing to detect only two types
model = Model(inputs=base_model.input, output=predictions)
########################################################################
## Freez the base model #################
for layer in base_model.layers:
layer.trainable = False # all layers are not trainable
def train_categorical(gpus, experiment_path, train_df_path, train_image_path, val_df_path, val_image_path, y_name, y_classes, augment_number,
model_type, model_save_name, epoch_number, learning_rate, decay, regularization, batch_size=32, img_height=224, img_width=224):
checkpoint = ModelCheckpoint(os.path.join(experiment_path, model_save_name+'.h5'), monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=False, mode='auto', period=25)
callbacks = [checkpoint]
#Session variables
traindf = pd.read_csv(train_df_path)
valdf = pd.read_csv(val_df_path)
freq_dict = get_freq_dict(traindf, y_name, y_classes)
num_labels = len(y_classes)
numTrainImgs = numImgs(traindf, y_name, y_classes)
numValImgs = numImgs(valdf, y_name, y_classes)
class_weight = list(map(lambda x: 1/freq_dict[x], y_classes))
#Generators
train_generator = make_batch(generator='categorical',
dataframe=traindf,
image_path=train_image_path,
y_name=y_name,
y_classes=y_classes,
batch_size=batch_size,
augment_number=augment_number,
height=img_height,
width=img_width,
forTrain=True
)
val_generator = make_batch(generator='categorical',
dataframe=valdf,
image_path=val_image_path,
y_name=y_name,
y_classes=y_classes,
batch_size=batch_size,
height=img_height,
width=img_width,
forTrain=False
)
#Model
if model_type == 'vgg16':
net_input = Input(shape=(img_height, img_width, 3))
conv_base = VGG16(
weights='imagenet',
include_top=False,
input_shape=(img_height, img_width, 3))(net_input)
conv_base.trainable = False
flatten1 = Flatten()(conv_base)
dropout1 = Dropout(0.5)(flatten1)
dense1 = Dense(
num_labels,
activation='softmax',
kernel_regularizer=regularizers.l2(regularization))(dropout1)
with tf.device('/cpu:0'):
model = Model(inputs=net_input, outputs=dense1)
elif model_type == 'resnet':
net_input = Input(shape=(img_height, img_width, 3))
conv_base = ResNet50(
weights='imagenet',
include_top=False,
input_shape=(img_height, img_width, 3))(net_input)
conv_base.trainable = False
flatten1 = Flatten()(conv_base)
dropout1 = Dropout(0.5)(flatten1)
dense1 = Dense(
num_labels,
activation='softmax',
kernel_regularizer=regularizers.l2(regularization))(dropout1)
with tf.device('/cpu:0'):
model = Model(inputs=net_input, outputs=dense1)
elif model_type == 'inception':
net_input = Input(shape=(img_height, img_width, 3))
conv_base = InceptionV3(
weights='imagenet',
include_top=False,
input_shape=(img_height, img_width, 3))(net_input)
conv_base.trainable = False
flatten1 = Flatten()(conv_base)
dropout1 = Dropout(0.5)(flatten1)
dense1 = Dense(
num_labels,
activation='softmax',
kernel_regularizer=regularizers.l2(regularization))(dropout1)
with tf.device('/cpu:0'):
model = Model(inputs=net_input, outputs=dense1)
else:
print('\nError in train_categorical: invalid model type\n')
multi_model = multi_gpu_model(model, gpus=gpus)
model.summary()
#Train
multi_model.compile(optimizers.RMSprop(lr=learning_rate, decay=decay), loss='categorical_crossentropy', metrics=['accuracy'])
history = multi_model.fit_generator(generator=train_generator,
steps_per_epoch=numTrainImgs//batch_size,
validation_data=val_generator,
validation_steps=numValImgs,
class_weight=class_weight,
epochs=epoch_number,
verbose=1,
callbacks=callbacks
)
#Save model parameters
model.save(os.path.join(experiment_path, model_save_name+'.h5'))
#Save model index meanings
with open(os.path.join(experiment_path, model_save_name+':indices.txt'), mode='w', encoding='utf-8') as filewrite:
csv_writer = csv.writer(filewrite, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
csv_writer.writerow(['class', 'frequency', 'index'])
for i in range(len(y_classes)):
csv_writer.writerow([y_classes[i], freq_dict[y_classes[i]], i])
#Plots
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.figure()
plt.plot(epochs, acc, 'bo', label='Training accuracy')
plt.plot(epochs, val_acc, 'r*', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend()
plt.savefig(os.path.join(experiment_path, 'accuracy.png'))
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'r*', label='Validation loss')
plt.title('Training and validation loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend()
plt.savefig(os.path.join(experiment_path, 'loss.png'))
from keras.applications import ResNet50
from keras.models import Model
import os
class_weight = {0: 0.05, 1: 0.95}
training_to_all_data_ratio = 0.9
nb_cross_val = 1
nb_epoch = 1000
batch_size = 32
dir_name = os.path.dirname(__file__)
dir_name = os.path.dirname(dir_name)
image_path = os.path.join(dir_name, 'data/input')
backbone_model = ResNet50(weights='imagenet')
backbone_model = Model(inputs=backbone_model.input,
outputs=backbone_model.get_layer(index=-2).output)
data = DataSet()
data.model = backbone_model
data.extract_features(image_path,
option='fixed frame amount',
number_of_frames=50)
data.read_risk_data("LCTable.csv")
data.convert_risk_to_one_hot(risk_threshold=0.05)
Data = data.video_features
label = data.risk_one_hot
model = Models(nb_epoch=nb_epoch,
def load_model():
# load the pre-trained Keras model (here we are using a model
# pre-trained on ImageNet and provided by Keras, but you can
# substitute in your own networks just as easily)
global model
model = ResNet50(weights="imagenet")
def classify_process():
# load the pre-trained Keras model (here we are using a model
# pre-trained on ImageNet and provided by Keras, but you can
# substitute in your own networks just as easily)
print("* Loading model...")
model = ResNet50(weights="imagenet")
print("* Model loaded")
# continually pool for new images to classify
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(IMAGE_QUEUE, 0, BATCH_SIZE - 1)
imageIDs = []
batch = None
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = base64_decode_image(
q["image"], IMAGE_DTYPE,
(1, IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_CHANS))
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# classify the batch
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = imagenet_utils.decode_predictions(preds)
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(imageIDs, results):
# initialize the list of output predictions
output = []
# loop over the results and add them to the list of
# output predictions
for (imagenetID, label, prob) in resultSet:
r = {"label": label, "probability": float(prob)}
output.append(r)
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
db.set(imageID, json.dumps(output))
# remove the set of images from our queue
db.ltrim(IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(SERVER_SLEEP)
def load_model():
global graph
global model
model = ResNet50(weights="imagenet")
graph = tf.get_default_graph()
test_STEPS = np.ceil(112163.0 / hps.batch_size)
CHANNEL = 3 if hps.rgb is True else 1
if hps.debug:
hps.epochs = 2
hps.eval_samples_num = 3400
STEPS = 500 # debug的时候steps可以设置小一点
valid_STEPS= 50
print("\n---------debug mode!---------\n")
print("EPOCHS = %d \nSTEPS = %d \nvalid_STEPS = %d " % (hps.epochs, STEPS, valid_STEPS))
if hps.use_pretrain_model:
pretrain_model = ResNet50(weights="imagenet", include_top=False)
x = pretrain_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predict = Dense(NCATS, activation='softmax')(x)
single_model = Model(inputs=pretrain_model.input, outputs=predict)
else:
single_model = ResNet50(input_shape=(hps.image_size, hps.image_size, CHANNEL), weights=None, classes=NCATS)
print("\n ---------------Using %d GPUs----------------\n" % hps.gpus)
model = multi_gpu_model(single_model, gpus=hps.gpus)
model.compile(optimizer=Adam(lr=0.002), loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy])
print(model.summary())
return imgs_resize, lbls, lbls_str
#%%
train_images, train_labels, train_labels_str = resnet_transfer_preparedata(
no=0)
test_images, test_labels, test_labels_str = resnet_transfer_preparedata('test',
no=0)
train_labels_cat = to_categorical(train_labels, num_classes=10)
test_labels_cat = to_categorical(test_labels, num_classes=10)
#%% prepare new model
base_model = ResNet50(include_top=False,
weights='imagenet',
input_shape=[38, 38, 3])
#%% freeze: set base_model layers to non trainable , freeze early stages,
# assuming that these will do extraction of basic features, and retrain later ones
# going with the assumption that this set is very differnt from the orignal set
for l in base_model.layers[:10]:
l.trainable = False
#%%
base_model.summary()
#%%
added_layers = base_model.output
def model_choose(depth, width, model_name="ResNet50", weights=None):
if model_name == "ResNet50":
base = ResNet50(include_top=False,
weights='imagenet',
input_shape=(224, 224, 3),
pooling="avg")
prediction = Dense(
units=101,
kernel_initializer="he_normal",
use_bias=False,
activation="softmax",
name="pred_age"
)(
base.output
) #he_normal draws samples from normal distribution of weights for intialization of layers
model = Model(inputs=base.input, outputs=prediction, name="ResNet-50")
return model
elif model_name == "AlexNet":
input_shape = (200, 200, 3)
num_classes = 101
input_layer = Input(shape=input_shape)
#First layer of model
x = ZeroPadding2D(padding=(0, 0))(input_layer)
x = Conv2D(filters=96,
kernel_size=(11, 11),
strides=(4, 4),
padding="valid",
kernel_regularizer=l2(0.0),
kernel_initializer="he_normal",
name="conv1")(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = MaxPool2D(pool_size=(3, 3),
strides=(2, 2),
padding="valid",
name="maxpool1")(x)
#Second layer of model
x = Conv2D(filters=256,
kernel_size=(5, 5),
strides=(1, 1),
padding="same",
kernel_regularizer=l2(0.0),
kernel_initializer="he_normal",
name="conv2")(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = MaxPool2D(pool_size=(3, 3),
strides=(2, 2),
padding="valid",
name="maxpool2")(x)
#Third layer of model
x = Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
kernel_regularizer=l2(0.0),
kernel_initializer="he_normal",
name="conv3")(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
#Fourth layer of model
x = Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
kernel_regularizer=l2(0.0),
kernel_initializer="he_normal",
name="conv4")(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
#Fifth layer of model
x = Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
kernel_regularizer=l2(0.0),
kernel_initializer="he_normal",
name="conv5")(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = MaxPool2D(pool_size=(3, 3),
strides=(2, 2),
padding="valid",
name="maxpool3")(x)
#Sixth layer of model
x = Flatten()(x)
#x = Dropout(0.5)
x = Dense(units=4096)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
#Seventh layer of model
#x = Dropout(0.5)
x = Dense(units=4096)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
#Eighth layer of model
x = Dense(units=num_classes)(x)
x = BatchNormalization()(x)
x = Activation("softmax")(x)
if weights is not None:
x.load_weights(weights)
model = Model(input_layer, x, name="AlexNet_8")
return model
else:
print("Wide ResNet model")
return buildmodel(64, depth, width)
def load_models():
# Set up global variables that will be used throughout the "routes". This will be done on server start up
global model
global model_custom
global face_cascade
global dog_names
global graph
# Load the models as well as the face classifier
face_cascade = cv2.CascadeClassifier(
"dogclassifierapp/static/haarcascade_frontalface_alt.xml")
model = ResNet50(weights='imagenet', include_top=False)
model_custom = load_model("dogclassifierapp/static/ResNetDog.h5")
# Prepare the dog_names to be retrieved after predicitions are made to provide the predicted name
dog_names = [
'ages/train/001.Affenpinscher', 'ages/train/002.Afghan_hound',
'ages/train/003.Airedale_terrier', 'ages/train/004.Akita',
'ages/train/005.Alaskan_malamute',
'ages/train/006.American_eskimo_dog',
'ages/train/007.American_foxhound',
'ages/train/008.American_staffordshire_terrier',
'ages/train/009.American_water_spaniel',
'ages/train/010.Anatolian_shepherd_dog',
'ages/train/011.Australian_cattle_dog',
'ages/train/012.Australian_shepherd',
'ages/train/013.Australian_terrier', 'ages/train/014.Basenji',
'ages/train/015.Basset_hound', 'ages/train/016.Beagle',
'ages/train/017.Bearded_collie', 'ages/train/018.Beauceron',
'ages/train/019.Bedlington_terrier', 'ages/train/020.Belgian_malinois',
'ages/train/021.Belgian_sheepdog', 'ages/train/022.Belgian_tervuren',
'ages/train/023.Bernese_mountain_dog', 'ages/train/024.Bichon_frise',
'ages/train/025.Black_and_tan_coonhound',
'ages/train/026.Black_russian_terrier', 'ages/train/027.Bloodhound',
'ages/train/028.Bluetick_coonhound', 'ages/train/029.Border_collie',
'ages/train/030.Border_terrier', 'ages/train/031.Borzoi',
'ages/train/032.Boston_terrier', 'ages/train/033.Bouvier_des_flandres',
'ages/train/034.Boxer', 'ages/train/035.Boykin_spaniel',
'ages/train/036.Briard', 'ages/train/037.Brittany',
'ages/train/038.Brussels_griffon', 'ages/train/039.Bull_terrier',
'ages/train/040.Bulldog', 'ages/train/041.Bullmastiff',
'ages/train/042.Cairn_terrier', 'ages/train/043.Canaan_dog',
'ages/train/044.Cane_corso', 'ages/train/045.Cardigan_welsh_corgi',
'ages/train/046.Cavalier_king_charles_spaniel',
'ages/train/047.Chesapeake_bay_retriever', 'ages/train/048.Chihuahua',
'ages/train/049.Chinese_crested', 'ages/train/050.Chinese_shar-pei',
'ages/train/051.Chow_chow', 'ages/train/052.Clumber_spaniel',
'ages/train/053.Cocker_spaniel', 'ages/train/054.Collie',
'ages/train/055.Curly-coated_retriever', 'ages/train/056.Dachshund',
'ages/train/057.Dalmatian', 'ages/train/058.Dandie_dinmont_terrier',
'ages/train/059.Doberman_pinscher', 'ages/train/060.Dogue_de_bordeaux',
'ages/train/061.English_cocker_spaniel',
'ages/train/062.English_setter',
'ages/train/063.English_springer_spaniel',
'ages/train/064.English_toy_spaniel',
'ages/train/065.Entlebucher_mountain_dog',
'ages/train/066.Field_spaniel', 'ages/train/067.Finnish_spitz',
'ages/train/068.Flat-coated_retriever',
'ages/train/069.French_bulldog', 'ages/train/070.German_pinscher',
'ages/train/071.German_shepherd_dog',
'ages/train/072.German_shorthaired_pointer',
'ages/train/073.German_wirehaired_pointer',
'ages/train/074.Giant_schnauzer',
'ages/train/075.Glen_of_imaal_terrier',
'ages/train/076.Golden_retriever', 'ages/train/077.Gordon_setter',
'ages/train/078.Great_dane', 'ages/train/079.Great_pyrenees',
'ages/train/080.Greater_swiss_mountain_dog',
'ages/train/081.Greyhound', 'ages/train/082.Havanese',
'ages/train/083.Ibizan_hound', 'ages/train/084.Icelandic_sheepdog',
'ages/train/085.Irish_red_and_white_setter',
'ages/train/086.Irish_setter', 'ages/train/087.Irish_terrier',
'ages/train/088.Irish_water_spaniel', 'ages/train/089.Irish_wolfhound',
'ages/train/090.Italian_greyhound', 'ages/train/091.Japanese_chin',
'ages/train/092.Keeshond', 'ages/train/093.Kerry_blue_terrier',
'ages/train/094.Komondor', 'ages/train/095.Kuvasz',
'ages/train/096.Labrador_retriever', 'ages/train/097.Lakeland_terrier',
'ages/train/098.Leonberger', 'ages/train/099.Lhasa_apso',
'ages/train/100.Lowchen', 'ages/train/101.Maltese',
'ages/train/102.Manchester_terrier', 'ages/train/103.Mastiff',
'ages/train/104.Miniature_schnauzer',
'ages/train/105.Neapolitan_mastiff', 'ages/train/106.Newfoundland',
'ages/train/107.Norfolk_terrier', 'ages/train/108.Norwegian_buhund',
'ages/train/109.Norwegian_elkhound',
'ages/train/110.Norwegian_lundehund', 'ages/train/111.Norwich_terrier',
'ages/train/112.Nova_scotia_duck_tolling_retriever',
'ages/train/113.Old_english_sheepdog', 'ages/train/114.Otterhound',
'ages/train/115.Papillon', 'ages/train/116.Parson_russell_terrier',
'ages/train/117.Pekingese', 'ages/train/118.Pembroke_welsh_corgi',
'ages/train/119.Petit_basset_griffon_vendeen',
'ages/train/120.Pharaoh_hound', 'ages/train/121.Plott',
'ages/train/122.Pointer', 'ages/train/123.Pomeranian',
'ages/train/124.Poodle', 'ages/train/125.Portuguese_water_dog',
'ages/train/126.Saint_bernard', 'ages/train/127.Silky_terrier',
'ages/train/128.Smooth_fox_terrier', 'ages/train/129.Tibetan_mastiff',
'ages/train/130.Welsh_springer_spaniel',
'ages/train/131.Wirehaired_pointing_griffon',
'ages/train/132.Xoloitzcuintli', 'ages/train/133.Yorkshire_terrier'
]
# Set the default graph as otherwise the model won't work
graph = tf.get_default_graph()
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)
encoded_Y = encoder.transform(labels)
dummy_y = np_utils.to_categorical(encoded_Y)
num_subjects = np.shape(dummy_y)[1]
# identify train set
dummy_y_val = np.array(dummy_y[0:len_val_set])
X_val = np.array(faces[0:len_val_set])
# identify validation set
dummy_y_train = np.array(dummy_y[len_val_set:ntot])
X_train = np.array(faces[len_val_set:ntot])
print("Data prepared")
print("Preparing network")
# define the network
my_model = Sequential()
my_model.add(ResNet50(include_top=False, pooling='avg', weights='imagenet'))
my_model.add(Dense(num_subjects, activation='softmax'))
# Say not to train first layer (ResNet) model. It is already trained
my_model.layers[0].trainable = False
# load weights from checkpoint
# in case of already partially trained
# network with checkpoints
my_model.load_weights("weights.best.hdf5")
# compile the networ
my_model.compile(optimizer='sgd',
loss='categorical_crossentropy',
metrics=['accuracy'])
# checkpoint
filepath = "weights.best.hdf5"
checkpoint = ModelCheckpoint(filepath,
from keras.applications import VGG16, VGG19, InceptionV3, ResNet50, Xception
__network_model_dictionary = {
'Xception':
Xception(weights='imagenet',
include_top=False,
input_shape=input_layer_shape),
'VGG16':
VGG16(weights='imagenet', include_top=False,
input_shape=input_layer_shape),
'VGG19':
VGG19(weights='imagenet', include_top=False,
input_shape=input_layer_shape),
'ResNet50':
ResNet50(weights='imagenet',
include_top=False,
input_shape=input_layer_shape),
'InceptionV3':
InceptionV3(weights='imagenet',
include_top=False,
input_shape=input_layer_shape)
}
def load_base_network(network_model='VGG16', input_layer_shape=(197, 197, 3)):
"""Load a pretrained base network model.
Args:
network_model (string): A string which represents the base network model.
input_layer_shape (3d tensor): A 3d tensor (height x width x channels) which represents the input layer's shape.
args.add_argument('--iteration', type=str, default='0',
help='fork 명령어를 입력할때의 체크포인트로 설정됩니다. 체크포인트 옵션을 안주면 마지막 wall time 의 model 을 가져옵니다.')
args.add_argument('--pause', type=int, default=0, help='model 을 load 할때 1로 설정됩니다.')
config = args.parse_args()
# training parameters
nb_epoch = config.epoch
batch_size = config.batch_size
num_classes = config.num_classes
input_shape = (224, 224, 3) # input image shape
""" Model """
# Pretrained model
# base_model = MobileNet(weights='imagenet', include_top=False, pooling='max')
# base_model = ResNet50(weights='imagenet', include_top=False, input_shape=input_shape)
base_model = ResNet50(weights=None, include_top=False, input_shape=input_shape)
# base_model = VGG16(weights='imagenet', include_top=False)
# base_model = VGG19(weights='imagenet', include_top=False)
print('-------------------------- Base model ---------------------------')
base_model.summary()
print('-------------------------- Full model ---------------------------')
print()
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=x, name='fc1383')
# for layer in model.layers[:-1]:
# layer.trainable = False # Don't train initial pretrained weights
