def save_bottleneck_features():
model = MobileNet(include_top=False, weights='imagenet', input_shape=(150, 150, 3))
print('load model ok')
datagen = ImageDataGenerator(rescale=1. / 255)
# train set image generator
train_generator = datagen.flow_from_directory(
'/data/lebron/data/mytrain',
target_size=(150, 150),
batch_size=batch_size,
class_mode=None,
shuffle=False
)
# test set image generator
test_generator = datagen.flow_from_directory(
'/data/lebron/data/mytest',
target_size=(150, 150),
batch_size=batch_size,
class_mode=None,
shuffle=False
)
# load weight
model.load_weights(WEIGHTS_PATH_NO_TOP)
print('load weight ok')
# get bottleneck feature
bottleneck_features_train = model.predict_generator(train_generator, 10)
np.save(save_train_path, bottleneck_features_train)
bottleneck_features_validation = model.predict_generator(test_generator, 2)
np.save(save_test_path, bottleneck_features_validation)
def __init__(self, input_size):
input_image = Input(shape=(input_size, input_size, 3))
mobilenet = MobileNet(input_shape=(224, 224, 3), include_top=False)
mobilenet.load_weights("data/mobilenet_backend.h5")
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def __init__(self, input_shape):
input_image = Input(shape=tuple(input_shape))
mobilenet = MobileNet(input_shape=(224, 224, 3), include_top=False)
mobilenet.load_weights(MOBILENET_BACKEND_PATH)
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def __init__(self, input_size, weights):
input_image = Input(shape=(input_size, input_size, 3))
mobilenet = MobileNet(input_shape=(224,224,3), include_top=False)
if weights:
mobilenet.load_weights(weights)
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def __init__(self, input_size, weights):
input_image = Input(shape=(input_size, input_size, 3))
mobilenet = MobileNet(input_shape=(224, 224, 3), include_top=False)
if weights:
mobilenet.load_weights(weights)
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def __init__(self, input_size):
input_image = Input(shape=(input_size, input_size, 3))
mobilenet = MobileNet(input_shape=(224,224,3), include_top=False)
mobilenet.load_weights(MOBILENET_BACKEND_PATH)
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def __init__(self, input_size):
input_image = Input(shape=(input_size, input_size, 3))
mobilenet = MobileNet(input_shape=(input_size, input_size, 3),
include_top=False)
mobilenet.load_weights(MOBILENET_BACKEND_PATH, by_name=True)
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x)
def _build_model(self):
logger.info("Building mobilenet...")
print("building mobilenet")
input_image = Input(shape=(self.input_size, self.input_size, 3))
mobilenet = MobileNet(input_shape=(224, 224, 3), include_top=False)
mobilenet.load_weights(self.weight_file)
x = mobilenet(input_image)
return Model(input_image, x)
def __init__(self, model_path="weights/vasya_mobilenetv2_keypoints.h5", model_type = 'mobilenet_v2'):
if model_type == 'mobilenet':
model = MobileNet(input_shape=(112, 112, 3), classes=68*2, weights=None)
else:
model = MobileNetV2(input_shape=(112, 112, 3), classes=68*2, weights=None)
out = model.layers[-2].output
out = Dense(68*2, activation ='linear')(out)
model = Model(inputs = model.input, outputs = out)
model.compile(optimizer=Adam(), loss = 'mse')
with open(model_path, 'rb') as f:
model.load_weights(f)
self.model = model
def __init__(self, input_size):
input_image = Input(shape=input_size)
mobilenet = MobileNet(input_shape=(224,224,3), include_top=False)
if input_size[2] == 3:
try:
mobilenet.load_weights(MOBILENET_BACKEND_PATH)
except:
print("Unable to load backend weigths. Using a fresh model")
else:
print('pre trained weights are avaliable just for RGB network.')
x = mobilenet(input_image)
self.feature_extractor = Model(input_image, x, name='MobileNet_backend')
def mobilenet(weight_dir):
model = MobileNet(input_shape=(64, 64, 1),
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=True,
weights=None,
input_tensor=None,
pooling='avg',
classes=4)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.load_weights(weight_dir)
return model
class Navigation:
def __init__(self):
self.imageSub = message_filters.Subscriber(
"robot1/camera/rgb/image_raw", Image)
self.odometrySub = message_filters.Subscriber("robot1/odom", Odometry)
self.cmd_vel = rospy.Publisher("/robot1/mobile_base/commands/velocity",
Twist,
queue_size=1)
ts = message_filters.TimeSynchronizer(
[self.imageSub, self.odometrySub], 10)
ts.registerCallback(self.callback)
self.cv = CvBridge()
self.lastImage = None
self.OdomLX = None
self.OdomAZ = None
self.model = MobileNet()
self.model.load_weights(
"./weights/WeightsMobileNetTrain1/results/weights.59-0.01.hdf5")
self.model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
def callback(self, imageMsg, odometryMsg):
try:
cv = self.bridge.imgmsg_to_cv2(imageMsg, "mono8")
image = cv
self.lastImage = cv.resize(image, (224, 224))
self.OdomLX = odometryMsg.twist.twist.linear.x
self.OdomAZ = odometryMsg.twist.twist.angular.z
except Exception as e:
print(e)
def run(self):
batch = [self.lastImage]
inputModel = np.array(batch)
output = self.model.predict(inputModel, batch_size=1, verbose=0)
move_cmd = Twist()
move_cmd.linear.x = output[0][0]
move_cmd.angular.z = output[0][1]
def main():
# Parameters
if len(sys.argv) == 3:
superclass = sys.argv[1]
model_weight = sys.argv[2]
else:
print('Parameters error')
exit()
# The constants
classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24}
testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'}
date = '20180321'
# Feature extraction model
base_model = MobileNet(include_top=True, weights=None,
input_tensor=None, input_shape=None,
pooling=None, classes=classNum[superclass[0]])
base_model.load_weights(model_weight)
base_model.summary()
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('global_average_pooling2d_1').output)
imgdir_train = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date\
+'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date
imgdir_test = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_test_'+date
categories = os.listdir(imgdir_train)
categories.append('test')
num = 0
for eachclass in categories:
if eachclass[0] == '.':
continue
if eachclass == 'test':
classpath = imgdir_test
else:
classpath = imgdir_train+'/'+eachclass
num += len(os.listdir(classpath))
print('Total image number = '+str(num))
features_all = np.ndarray((num, 1024))
labels_all = list()
images_all = list()
idx = 0
# Feature extraction
for iter in tqdm(range(len(categories))):
eachclass = categories[iter]
if eachclass[0] == '.':
continue
if eachclass == 'test':
classpath = imgdir_test
else:
classpath = imgdir_train+'/'+eachclass
imgs = os.listdir(classpath)
for eachimg in imgs:
if eachimg[0] == '.':
continue
img_path = classpath+'/'+eachimg
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
feature = model.predict(x)
features_all[idx, :] = feature
labels_all.append(eachclass)
images_all.append(eachimg)
idx += 1
features_all = features_all[:idx, :]
labels_all = labels_all[:idx]
images_all = images_all[:idx]
data_all = {'features_all':features_all, 'labels_all':labels_all,
'images_all':images_all}
# Save features
savename = 'features_' + superclass + '.pickle'
fsave = open(savename, 'wb')
pickle.dump(data_all, fsave)
fsave.close()
# x = Dense(512, activation='relu')(x)
# x = Dropout(rate=0.3)(x)
# predictions = Dense(2, activation='softmax')(x)
# d_model = Model(inputs=base_model.input, outputs=predictions)
#
# for layer in base_model.layers:
# layer.trainable = False
#
# for layer in d_model.layers[:]:
# print(layer.name, layer.trainable)
#
# print(d_model.summary())
# d_model.compile(optimizer=SGD(lr=1e-6, momentum=0.9), loss=EuiLoss, metrics=[y_t, y_pre, Acc])
#3 MobileNet============================================================================================================
base_model = MobileNet(weights=None, include_top=False)
base_model.load_weights(
filepath=r'F:\@data_response_2d\weight\3_mobilenet.h5', by_name=True)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dropout(rate=0.3)(x)
x = Dense(512, activation='relu')(x)
x = Dropout(rate=0.3)(x)
predictions = Dense(2, activation='softmax')(x)
d_model = Model(inputs=base_model.input, outputs=predictions)
for layer in base_model.layers:
layer.trainable = False
for layer in d_model.layers[:]:
print(layer.name, layer.trainable)
pause()
params = json.load(json_file)
#Set the path of train and test. Also set the path to save the model
outing = "./"
weightfile = "./NIMA.hdf5"
#Define the base model for loading the structure of the mobilenet architecture.
base_model = MobileNet((224, 224, 3),
alpha=1,
include_top=False,
pooling='avg',
weights=None)
#Load the weights in the model from the NIMA architecture. We only require the convolution layers
#of the NIMA architecture
base_model.load_weights(weightfile, by_name=True)
#Define a model cut till the conv_pw_12_relu layer.
modelcut = build_bottleneck_model(base_model, 'conv_pw_13_relu')
#Add extra Depthwise conv BLocks
interimoutput = depthwise_conv_block(modelcut.output,
2048,
1,
1,
strides=(2, 2),
block_id=14)
#Do Global Average pooling as intended in the NIMA paper.
interimoutput = GlobalAveragePooling2D()(interimoutput)
def mobile_u_net(input_size):
num_classes = 1
# Build contracting path using pre-trained MobileNet
contracting_path = MobileNet(input_shape=(input_size, input_size, 3),
include_top=False,
weights=None)
contracting_path.load_weights('weights/mobilenet_1_0_224_tf_no_top.h5')
for layer in contracting_path.layers:
layer.trainable = False
# Build expanding path based on U-Net straucture
center = contracting_path.output
up4 = UpSampling2D((2, 2))(center)
conv_pw_11_relu = contracting_path.get_layer(name='conv_pw_11_relu').output
up4 = concatenate([up4, conv_pw_11_relu], axis=3)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = PReLU()(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = PReLU()(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = PReLU()(up4)
# 64
up3 = UpSampling2D((2, 2))(up4)
conv_pw_5_relu = contracting_path.get_layer(name='conv_pw_5_relu').output
up3 = concatenate([up3, conv_pw_5_relu], axis=3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = PReLU()(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = PReLU()(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = PReLU()(up3)
# 128
up2 = UpSampling2D((2, 2))(up3)
conv_pw_3_relu = contracting_path.get_layer(name='conv_pw_3_relu').output
up2 = concatenate([up2, conv_pw_3_relu], axis=3)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = PReLU()(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = PReLU()(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = PReLU()(up2)
# 256
up1 = UpSampling2D((2, 2))(up2)
conv_pw_1_relu = contracting_path.get_layer(name='conv_pw_1_relu').output
up1 = concatenate([up1, conv_pw_1_relu], axis=3)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = PReLU()(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = PReLU()(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = PReLU()(up1)
# 512
up0 = UpSampling2D((2, 2))(up1)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = PReLU()(up0)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = PReLU()(up0)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = PReLU()(up0)
# 1024
classifier = Conv2D(num_classes, (1, 1), activation='sigmoid')(up0)
model = Model(inputs=contracting_path.input, outputs=classifier)
return model
test_datagen = ImageDataGenerator(
# rescale = 1./255,
horizontal_flip = True,
fill_mode = "nearest",
zoom_range = 0.3,
width_shift_range = 0.3,
height_shift_range=0.3,
rotation_range=180)
test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size = (img_height, img_width),
batch_size = batch_size,
class_mode = "categorical")
#####get model#####
model = MobileNet(weights=None, classes=4)
model.load_weights('/model/mobnet.h5')
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
score,acc = model.evaluate_generator(test_generator, steps = (1050/batch_size)+1)
# calculate predictions
# pred = model.predict(test_features)
# print(test_labels.shape,pred.shape)
# print(test_labels[0],pred[0])
target_names = ['blade','gun','others','shuriken']
print("Test score: " + str(score))
print("Test accuracy: " + str(acc))
# print(classification_report(test_labels, pred,target_names=target_names))
testSamplesNumber = countFiles(testFolder)
#model = resnet.ResnetBuilder.build_resnet_50((channels,img_width,img_height), numOfClasses) #_18 _34 _50 _101
#model = resnet_activity_reg.ResnetBuilder.build_resnet_50((channels,img_width,img_height), numOfClasses) #_18 _34 _50 _101
model = MobileNet(
include_top=True,
weights=None,
# ' input_tensor=Input(shape=input_shape))
alpha=0.1,
input_tensor=None,
input_shape=input_shape,
pooling='avg',
classes=2)
if modelContinueFlag:
model.load_weights(modelContinueWeigthsFile, by_name=False)
model.summary()
model.compile(
loss='categorical_crossentropy',
#model.compile(loss='categorical_hinge',
optimizer=Adam(lr=startingLeraningRate,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0),
#optimizer=RMSprop(lr=startingLeraningRate, rho=0.9, epsilon=None, decay=0.0),
#optimizer=SGD(lr=startingLeraningRate, decay=1e-6, momentum=0.9, nesterov=True),
metrics=['accuracy', 'categorical_accuracy']
) # default lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0 or 0.00005
def build_model(image_size,
n_classes,
mode='training',
l2_regularization=0.0,
min_scale=0.1,
max_scale=0.9,
scales=None,
aspect_ratios_global=[0.5, 1.0, 2.0],
aspect_ratios_per_layer=None,
two_boxes_for_ar1=True,
steps=None,
offsets=None,
clip_boxes=False,
variances=[1.0, 1.0, 1.0, 1.0],
coords='centroids',
normalize_coords=False,
subtract_mean=None,
divide_by_stddev=None,
swap_channels=False,
confidence_thresh=0.01,
iou_threshold=0.45,
top_k=200,
nms_max_output_size=400,
return_predictor_sizes=False):
'''
Build a Keras model with SSD architecture, see references.
The model consists of convolutional feature layers and a number of convolutional
predictor layers that take their input from different feature layers.
The model is fully convolutional.
'''
n_predictor_layers = 4 # The number of predictor conv layers in the network
n_classes += 1 # Account for the background class.
l2_reg = l2_regularization # Make the internal name shorter.
img_height, img_width, img_channels = image_size[0], image_size[
1], image_size[2]
############################################################################
# Get a few exceptions out of the way.
############################################################################
if aspect_ratios_global is None and aspect_ratios_per_layer is None:
raise ValueError(
"`aspect_ratios_global` and `aspect_ratios_per_layer` cannot both be None. At least one needs to be specified."
)
if aspect_ratios_per_layer:
if len(aspect_ratios_per_layer) != n_predictor_layers:
raise ValueError(
"It must be either aspect_ratios_per_layer is None or len(aspect_ratios_per_layer) == {}, but len(aspect_ratios_per_layer) == {}."
.format(n_predictor_layers, len(aspect_ratios_per_layer)))
if (min_scale is None or max_scale is None) and scales is None:
raise ValueError(
"Either `min_scale` and `max_scale` or `scales` need to be specified."
)
if scales:
if len(scales) != n_predictor_layers + 1:
raise ValueError(
"It must be either scales is None or len(scales) == {}, but len(scales) == {}."
.format(n_predictor_layers + 1, len(scales)))
else: # If no explicit list of scaling factors was passed, compute the list of scaling factors from `min_scale` and `max_scale`
scales = np.linspace(min_scale, max_scale, n_predictor_layers + 1)
if len(
variances
) != 4: # We need one variance value for each of the four box coordinates
raise ValueError(
"4 variance values must be pased, but {} values were received.".
format(len(variances)))
variances = np.array(variances)
if np.any(variances <= 0):
raise ValueError(
"All variances must be >0, but the variances given are {}".format(
variances))
if (not (steps is None)) and (len(steps) != n_predictor_layers):
raise ValueError(
"You must provide at least one step value per predictor layer.")
if (not (offsets is None)) and (len(offsets) != n_predictor_layers):
raise ValueError(
"You must provide at least one offset value per predictor layer.")
############################################################################
# Compute the anchor box parameters.
############################################################################
# Set the aspect ratios for each predictor layer. These are only needed for the anchor box layers.
if aspect_ratios_per_layer:
aspect_ratios = aspect_ratios_per_layer
else:
aspect_ratios = [aspect_ratios_global] * n_predictor_layers
# Compute the number of boxes to be predicted per cell for each predictor layer.
# We need this so that we know how many channels the predictor layers need to have.
if aspect_ratios_per_layer:
n_boxes = []
for ar in aspect_ratios_per_layer:
if (1 in ar) & two_boxes_for_ar1:
n_boxes.append(len(ar) +
1) # +1 for the second box for aspect ratio 1
else:
n_boxes.append(len(ar))
else: # If only a global aspect ratio list was passed, then the number of boxes is the same for each predictor layer
if (1 in aspect_ratios_global) & two_boxes_for_ar1:
n_boxes = len(aspect_ratios_global) + 1
else:
n_boxes = len(aspect_ratios_global)
n_boxes = [n_boxes] * n_predictor_layers
if steps is None:
steps = [None] * n_predictor_layers
if offsets is None:
offsets = [None] * n_predictor_layers
############################################################################
# Define functions for the Lambda layers below.
############################################################################
def identity_layer(tensor):
return tensor
def input_mean_normalization(tensor):
return tensor - np.array(subtract_mean)
def input_stddev_normalization(tensor):
return tensor / np.array(divide_by_stddev)
def input_channel_swap(tensor):
if len(swap_channels) == 3:
return K.stack([
tensor[..., swap_channels[0]], tensor[..., swap_channels[1]],
tensor[..., swap_channels[2]]
],
axis=-1)
elif len(swap_channels) == 4:
return K.stack([
tensor[..., swap_channels[0]], tensor[..., swap_channels[1]],
tensor[..., swap_channels[2]], tensor[..., swap_channels[3]]
],
axis=-1)
############################################################################
# Build the network.
############################################################################
base_model = MobileNet(input_shape=(img_height, img_width, img_channels),
weights=None,
include_top=False)
base_model.load_weights("G:/keras_weights/mobilenet_1_0_224_tf_no_top.h5")
#base_model.summary()
x = base_model.input
#base_model.layers[3].output
conv4 = base_model.get_layer("conv_pw_4_relu").output
conv5 = base_model.get_layer("conv_pw_6_relu").output
conv6 = base_model.get_layer("conv_pw_12_relu").output
conv7 = base_model.get_layer("conv_pw_13_relu").output
# Build the convolutional predictor layers on top of conv layers 4, 5, 6, and 7.
# We build two predictor layers on top of each of these layers: One for class prediction (classification), one for box coordinate prediction (localization)
# We precidt `n_classes` confidence values for each box, hence the `classes` predictors have depth `n_boxes * n_classes`
# We predict 4 box coordinates for each box, hence the `boxes` predictors have depth `n_boxes * 4`
# Output shape of `classes`: `(batch, height, width, n_boxes * n_classes)`
classes4 = Conv2D(n_boxes[0] * n_classes, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='classes4')(conv4)
classes5 = Conv2D(n_boxes[1] * n_classes, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='classes5')(conv5)
classes6 = Conv2D(n_boxes[2] * n_classes, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='classes6')(conv6)
classes7 = Conv2D(n_boxes[3] * n_classes, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='classes7')(conv7)
# Output shape of `boxes`: `(batch, height, width, n_boxes * 4)`
boxes4 = Conv2D(n_boxes[0] * 4, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='boxes4')(conv4)
boxes5 = Conv2D(n_boxes[1] * 4, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='boxes5')(conv5)
boxes6 = Conv2D(n_boxes[2] * 4, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='boxes6')(conv6)
boxes7 = Conv2D(n_boxes[3] * 4, (3, 3),
strides=(1, 1),
padding="same",
kernel_initializer='he_normal',
kernel_regularizer=l2(l2_reg),
name='boxes7')(conv7)
# Generate the anchor boxes
# Output shape of `anchors`: `(batch, height, width, n_boxes, 8)`
anchors4 = AnchorBoxes(img_height,
img_width,
this_scale=scales[0],
next_scale=scales[1],
aspect_ratios=aspect_ratios[0],
two_boxes_for_ar1=two_boxes_for_ar1,
this_steps=steps[0],
this_offsets=offsets[0],
clip_boxes=clip_boxes,
variances=variances,
coords=coords,
normalize_coords=normalize_coords,
name='anchors4')(boxes4)
anchors5 = AnchorBoxes(img_height,
img_width,
this_scale=scales[1],
next_scale=scales[2],
aspect_ratios=aspect_ratios[1],
two_boxes_for_ar1=two_boxes_for_ar1,
this_steps=steps[1],
this_offsets=offsets[1],
clip_boxes=clip_boxes,
variances=variances,
coords=coords,
normalize_coords=normalize_coords,
name='anchors5')(boxes5)
anchors6 = AnchorBoxes(img_height,
img_width,
this_scale=scales[2],
next_scale=scales[3],
aspect_ratios=aspect_ratios[2],
two_boxes_for_ar1=two_boxes_for_ar1,
this_steps=steps[2],
this_offsets=offsets[2],
clip_boxes=clip_boxes,
variances=variances,
coords=coords,
normalize_coords=normalize_coords,
name='anchors6')(boxes6)
anchors7 = AnchorBoxes(img_height,
img_width,
this_scale=scales[3],
next_scale=scales[4],
aspect_ratios=aspect_ratios[3],
two_boxes_for_ar1=two_boxes_for_ar1,
this_steps=steps[3],
this_offsets=offsets[3],
clip_boxes=clip_boxes,
variances=variances,
coords=coords,
normalize_coords=normalize_coords,
name='anchors7')(boxes7)
# Reshape the class predictions, yielding 3D tensors of shape `(batch, height * width * n_boxes, n_classes)`
# We want the classes isolated in the last axis to perform softmax on them
classes4_reshaped = Reshape((-1, n_classes),
name='classes4_reshape')(classes4)
classes5_reshaped = Reshape((-1, n_classes),
name='classes5_reshape')(classes5)
classes6_reshaped = Reshape((-1, n_classes),
name='classes6_reshape')(classes6)
classes7_reshaped = Reshape((-1, n_classes),
name='classes7_reshape')(classes7)
# Reshape the box coordinate predictions, yielding 3D tensors of shape `(batch, height * width * n_boxes, 4)`
# We want the four box coordinates isolated in the last axis to compute the smooth L1 loss
boxes4_reshaped = Reshape((-1, 4), name='boxes4_reshape')(boxes4)
boxes5_reshaped = Reshape((-1, 4), name='boxes5_reshape')(boxes5)
boxes6_reshaped = Reshape((-1, 4), name='boxes6_reshape')(boxes6)
boxes7_reshaped = Reshape((-1, 4), name='boxes7_reshape')(boxes7)
# Reshape the anchor box tensors, yielding 3D tensors of shape `(batch, height * width * n_boxes, 8)`
anchors4_reshaped = Reshape((-1, 8), name='anchors4_reshape')(anchors4)
anchors5_reshaped = Reshape((-1, 8), name='anchors5_reshape')(anchors5)
anchors6_reshaped = Reshape((-1, 8), name='anchors6_reshape')(anchors6)
anchors7_reshaped = Reshape((-1, 8), name='anchors7_reshape')(anchors7)
# Concatenate the predictions from the different layers and the assosciated anchor box tensors
# Axis 0 (batch) and axis 2 (n_classes or 4, respectively) are identical for all layer predictions,
# so we want to concatenate along axis 1
# Output shape of `classes_concat`: (batch, n_boxes_total, n_classes)
classes_concat = Concatenate(axis=1, name='classes_concat')([
classes4_reshaped, classes5_reshaped, classes6_reshaped,
classes7_reshaped
])
# Output shape of `boxes_concat`: (batch, n_boxes_total, 4)
boxes_concat = Concatenate(axis=1, name='boxes_concat')(
[boxes4_reshaped, boxes5_reshaped, boxes6_reshaped, boxes7_reshaped])
# Output shape of `anchors_concat`: (batch, n_boxes_total, 8)
anchors_concat = Concatenate(axis=1, name='anchors_concat')([
anchors4_reshaped, anchors5_reshaped, anchors6_reshaped,
anchors7_reshaped
])
# The box coordinate predictions will go into the loss function just the way they are,
# but for the class predictions, we'll apply a softmax activation layer first
classes_softmax = Activation('softmax',
name='classes_softmax')(classes_concat)
# Concatenate the class and box coordinate predictions and the anchors to one large predictions tensor
# Output shape of `predictions`: (batch, n_boxes_total, n_classes + 4 + 8)
predictions = Concatenate(axis=2, name='predictions')(
[classes_softmax, boxes_concat, anchors_concat])
if mode == 'training':
model = Model(inputs=x, outputs=predictions)
elif mode == 'inference':
decoded_predictions = DecodeDetections(
confidence_thresh=confidence_thresh,
iou_threshold=iou_threshold,
top_k=top_k,
nms_max_output_size=nms_max_output_size,
coords=coords,
normalize_coords=normalize_coords,
img_height=img_height,
img_width=img_width,
name='decoded_predictions')(predictions)
model = Model(inputs=x, outputs=decoded_predictions)
elif mode == 'inference_fast':
decoded_predictions = DecodeDetectionsFast(
confidence_thresh=confidence_thresh,
iou_threshold=iou_threshold,
top_k=top_k,
nms_max_output_size=nms_max_output_size,
coords=coords,
normalize_coords=normalize_coords,
img_height=img_height,
img_width=img_width,
name='decoded_predictions')(predictions)
model = Model(inputs=x, outputs=decoded_predictions)
else:
raise ValueError(
"`mode` must be one of 'training', 'inference' or 'inference_fast', but received '{}'."
.format(mode))
if return_predictor_sizes:
# The spatial dimensions are the same for the `classes` and `boxes` predictor layers.
predictor_sizes = np.array([
classes4._keras_shape[1:3], classes5._keras_shape[1:3],
classes6._keras_shape[1:3], classes7._keras_shape[1:3]
])
return model, predictor_sizes
else:
return model
our_model = None
if args.ref_model == "mobilenet":
input_shape = (224, 224, 3)
input_tensor = Input(input_shape)
ref_model = MobileNet(weights=args.ref_model_weights,
include_top=False,
input_shape=input_shape,
input_tensor=input_tensor)
else:
assert args.ref_model_weights
ref_model, helper = build_model(args.ref_model,
args=None,
for_training=False)
ref_model.load_weights(args.ref_model_weights)
if args.our_model:
our_model, helper = build_model(args.our_model,
args=None,
for_training=False)
if args.our_model_weights:
print("Restore weights from '{}' for our model!".format(
args.our_model_weights))
our_model.load_weights(args.our_model_weights)
else:
print("Don't restore any weights for our model!")
if args.method == "diff":
print("Difference between:")
def main():
# Parameters
if len(sys.argv) == 4:
superclass = sys.argv[1]
imgmove = sys.argv[2]
if imgmove == 'False':
imgmove = False
else:
imgmove = True
lr = float(sys.argv[3])
else:
print('Parameters error')
exit()
# The constants
classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24}
testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'}
date = '20180321'
trainpath = 'trainval_' + superclass + '/train'
valpath = 'trainval_' + superclass + '/val'
if not os.path.exists('model'):
os.mkdir('model')
# Train/validation data preparation
if imgmove:
if not os.path.exists('trainval_' + superclass):
os.mkdir('trainval_' + superclass)
os.mkdir(trainpath)
os.mkdir(valpath)
sourcepath = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date\
+'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date
categories = os.listdir(sourcepath)
for eachclass in categories:
if eachclass[0] == superclass[0]:
print(eachclass)
os.mkdir(trainpath + '/' + eachclass)
os.mkdir(valpath + '/' + eachclass)
imgs = os.listdir(sourcepath + '/' + eachclass)
idx = 0
for im in imgs:
if idx % 8 == 0:
shutil.copyfile(
sourcepath + '/' + eachclass + '/' + im,
valpath + '/' + eachclass + '/' + im)
else:
shutil.copyfile(
sourcepath + '/' + eachclass + '/' + im,
trainpath + '/' + eachclass + '/' + im)
idx += 1
# Train and validation ImageDataGenerator
batchsize = 32
train_datagen = ImageDataGenerator(rescale=1. / 255,
rotation_range=15,
width_shift_range=5,
height_shift_range=5,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(trainpath,
target_size=(224, 224),
batch_size=batchsize)
valid_generator = test_datagen.flow_from_directory(valpath,
target_size=(224, 224),
batch_size=batchsize)
# Train MobileNet
model = MobileNet(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=classNum[superclass[0]])
model.summary()
model.compile(optimizer=SGD(lr=lr, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
steps_per_epoch = int(train_generator.n / batchsize)
validation_steps = int(valid_generator.n / batchsize)
visual = TensorBoard(log_dir="model/",
histogram_freq=0,
batch_size=batchsize,
write_graph=True)
weightname = 'model/mobile_' + superclass + '_wgt-{epoch:02d}-{val_loss:.4f}-{val_acc:.3f}.h5'
checkpointer = ModelCheckpoint(weightname,
monitor='val_loss',
verbose=0,
save_best_only=True,
save_weights_only=True,
mode='auto',
period=1)
model.load_weights('model/mobile_Animals_wgt.h5')
model.fit_generator(train_generator,
steps_per_epoch=steps_per_epoch,
epochs=100,
validation_data=valid_generator,
validation_steps=validation_steps,
callbacks=[checkpointer, visual])
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024
with open('./model/imagenet_class_index.json', encoding="utf-8") as f:
zisyo = json.load(f)
zisyo = {item["en"]: item["ja"] for item in zisyo}
model = MobileNet(input_shape=(128, 128, 3),
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000)
model.load_weights("./model/kerasmobilenet.h5")
bunrui = imagenet(model)
@app.route("/")
def index():
return render_template('index.html')
@app.route('/send', methods=['post'])
def posttest():
img_file = request.files['img_file']
fileName = img_file.filename
root, ext = os.path.splitext(fileName)
ext = ext.lower()
gazouketori = set([
