def create_model(model='',image_shape=[224,224],class_num=9):
train_image = fluid.layers.data(name='img', shape=[3] + image_shape, dtype='float32')
predict = AlexNet().net(train_image)
print('train_image.shape = ',train_image.shape)
return predict
def alexnet_train():
train_datagen = ImageDataGenerator(rescale=1. / 255)
validation_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(
train_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
shuffle=True,
class_mode='binary')
validation_generator = validation_datagen.flow_from_directory(
validation_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
shuffle=True,
class_mode='binary')
model = AlexNet(input_shape=(img_width, img_height, 3),
include_top=True,
save_weights=save_weights_dir)
model.compile(optimizer=Adam(),
loss='binary_crossentropy',
metrics=['accuracy'])
callback_list = [
EarlyStopping(monitor='val_acc', patience=5),
ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3)
]
model.fit_generator(train_generator,
steps_per_epoch=100,
epochs=20,
validation_data=validation_generator,
validation_steps=len(validation_generator),
callbacks=callback_list,
verbose=1)
return model
# initialize the training and validation dataset generators
trainGen = HDF5DatasetGenerator(config.TRAIN_HDF5,
128,
aug=aug,
preprocessors=[pp, mp, iap],
classes=2)
valGen = HDF5DatasetGenerator(config.VAL_HDF5,
128,
aug=aug,
preprocessors=[sp, mp, iap],
classes=2)
# initialize the optimizer and compile model
print("[INFO] compiling model")
opt = Adam(lr=1e-3)
model = AlexNet.build(width=227, height=227, depth=3, classes=2, reg=0.0002)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics="accuracy")
# construct the callback to save only the best model to disk based on the validation loss
checkpoint = ModelCheckpoint(args["weights"],
monitor="val_loss",
save_best_only=True,
verbose=1)
callbacks = [checkpoint]
# train the network
model.fit_generator(trainGen.generator(),
steps_per_epoch=trainGen.numImages // 128,
validation_data=valGen.generator(),
validation_steps=valGen.numImages // 128,
epochs=75,
transforms = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.ToTensor(), # normalize to [0, 1]
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
if args.imshow == True:
train_dataset = selfData(args.train_img, args.train_lab, transforms)
train_loader = DataLoader(train_dataset, batch_size = 64, shuffle = True, num_workers = 0, drop_last= False)
imgs, labels = train_loader.__iter__().__next__()
imshow(train_loader)
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
elif args.model == 'AlexNet':
net = AlexNet().to(device)
criterion = nn.CrossEntropyLoss()
if args.path == '':
train(args.epochs, args.train_img, args.train_lab, transforms, net, criterion)
PATH = './model.pth'
torch.save(net.state_dict(), PATH)
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
elif args.model == 'AlexNet':
net = AlexNet().to(device)
net.load_state_dict(torch.load(PATH))
else:
PATH = args.path
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True
# 设置随机数种子
setup_seed(20)
if __name__ == "__main__":
print("load_net...")
if args.model == 'mAlexNet':
net = mAlexNet()
elif args.model == 'AlexNet':
net = AlexNet()
elif args.model == "carnet":
net = carNet()
elif args.model == 'stn_shuf':
net = stn_shufflenet()
elif args.model == 'stn_trans_shuf':
net = stn_trans_shufflenet()
elif args.model == 'shuf':
net = torchvision.models.shufflenet_v2_x1_0(pretrained=False,
num_classes=2)
elif args.model == 'trans_shuf':
net = trans_shufflenet(shuff_type=args.shuf_type)
# print(args.shuf_type)
# net = net.cuda()
# for name, parameters in net.named_parameters():
# print(name, ':', parameters.size())
transforms.Resize(224),
transforms.RandomResizedCrop(224),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
])
if __name__=="__main__":
print("load_net...")
if args.model == 'mAlexNet':
net = mAlexNet()
elif args.model == 'AlexNet':
net = AlexNet()
elif args.model == "carnet":
net=carNet()
elif args.model=="googlenet":
net=models.googlenet()
num_fc = net.fc.in_features
net.fc = nn.Linear(num_fc, 2)
elif args.model=="vgg16":
net=models.vgg16(pretrained=True)
num_fc = net.classifier[6].in_features
net.classifier[6] = torch.nn.Linear(num_fc, 2)
for param in net.parameters():
param.requires_grad = False
# 但是参数全部固定了，也没法进行学习，所以我们不固定最后一层，即全连接层
for param in net.classifier[6].parameters():
param.requires_grad = True
shuffle=False,
num_workers=8,
pin_memory=True)
setattr(dataloader['val'], 'total_item_len', len(val_set))
dataloader['base'] = data.DataLoader(base_set,
batch_size=config.batch_size,
shuffle=False,
num_workers=8,
pin_memory=True)
setattr(dataloader['base'], 'total_item_len', len(base_set))
# ---------------------------- model ------------------------------------
if config.model_name == 'resnet18':
model = ResNet18(config.code_length, classes, config.class_mask)
elif config.model_name == 'alexnet':
model = AlexNet(config.code_length, classes, config.class_mask)
else:
print('undefined model ! ')
model = nn.DataParallel(model)
model.cuda()
# ---------------------------- loss and opt ------------------------------------
criterion = nn.CrossEntropyLoss()
criterion_hash = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=config.lr, momentum=0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
# ---------------------------- log and train ------------------------------------
log_file = open(
config.model_name + '_' + config.dataset + '_' +
if torch.cuda.is_available():
images = images.cuda()
labels = labels.cuda()
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
item += 1
return (correct / total)
if __name__ == "__main__":
if args.model == 'mAlexNet':
net = mAlexNet()
elif args.model == 'AlexNet':
net = AlexNet()
elif args.model == "carnet":
net = carNet()
elif args.model == 'stn_shuf':
net = stn_shufflenet()
elif args.model == 'stn_trans_shuf':
net = stn_trans_shufflenet()
elif args.model == 'shuf':
net = torchvision.models.shufflenet_v2_x1_0(pretrained=False,
num_classes=2)
elif args.model == 'trans_shuf':
net = trans_shufflenet()
torch.set_default_tensor_type('torch.FloatTensor')
print("test net:carNet..")
# print({k.replace('module.',''):v for k,v in torch.load(args.path,map_location="cpu").items()})
# exit()
def model_fn(features, labels, mode, params):
"""Model function for tf.estimator
Args:
features: input batch of images
labels: labels of the images
mode: can be one of tf.estimator.ModeKeys.{TRAIN, EVAL, PREDICT}
params: dictionary of hyperparameters of the model (ex: `params.learning_rate`)
Returns:
model_spec: tf.estimator.EstimatorSpec object
"""
# Unpack images
images = features
images = tf.reshape(images, [-1, params.image_size, params.image_size, 3])
assert images.shape[1:] == [params.image_size, params.image_size,
3], "{}".format(images.shape)
# -----------------------------------------------------------
# MODEL: define the layers of the model
train_layers = ['fc8', 'fclat', 'fc7', 'fc6']
alexnet_model = AlexNet(images, train_layers, params, mode)
# Link variable to model output
score = alexnet_model.fc8
embeddings_bin = tf.cast(tf.round(alexnet_model.fclat), tf.bool)
embeddings_float = alexnet_model.fc7
# Creating a prediction dictionary
predictions = {
'bit_codes': embeddings_bin,
'float_codes': embeddings_float
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode, predictions=predictions)
# Cast labels
labels = tf.cast(labels, tf.int32)
# Op for calculating the loss
with tf.name_scope("softmax_cross_ent"):
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=score,
labels=labels))
# Model's predictions
pred = tf.nn.softmax(score)
eval_metric_ops = {
"Evaluation_Accuracy":
tf.metrics.accuracy(labels=tf.argmax(labels, 1),
predictions=tf.argmax(pred, 1))
}
if mode == tf.estimator.ModeKeys.EVAL:
return tf.estimator.EstimatorSpec(mode,
loss=loss,
eval_metric_ops=eval_metric_ops)
# List of trainable variables of the layers we want to train
var_list = [
v for v in tf.trainable_variables()
if v.name.split('/')[0] in train_layers
]
# Train op
# Adapted from https://github.com/thulab/DeepHash
with tf.name_scope("train"):
gst = tf.train.get_or_create_global_step()
optimiser = tf.train.GradientDescentOptimizer(params.learning_rate)
# Get gradients of all trainable variables
grads_and_vars = optimiser.compute_gradients(loss, var_list)
fc6w_grad, _ = grads_and_vars[-8]
fc6b_grad, _ = grads_and_vars[-7]
fc7w_grad, _ = grads_and_vars[-6]
fc7b_grad, _ = grads_and_vars[-5]
fclatw_grad, _ = grads_and_vars[-4]
fclatb_grad, _ = grads_and_vars[-3]
fc8w_grad, _ = grads_and_vars[-2]
fc8b_grad, _ = grads_and_vars[-1]
# Apply gradient descent to the trainable variables
train_op = optimiser.apply_gradients([(fc6w_grad, var_list[0]),
(fc6b_grad, var_list[1]),
(fc7w_grad, var_list[2]),
(fc7b_grad, var_list[3]),
(fclatw_grad, var_list[4]),
(fclatb_grad, var_list[5]),
(fc8w_grad, var_list[6]),
(fc8b_grad, var_list[7])],
global_step=gst)
# Add gradients to summary
for gradient, var in grads_and_vars:
tf.summary.histogram(var.name[:-2] + '/gradient', gradient)
# Add the variables we train to the summary
for var in var_list:
tf.summary.histogram(var.name[:-2], var)
# Evaluation op: Accuracy of the model
with tf.name_scope("accuracy"):
correctness = tf.equal(tf.argmax(pred, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correctness, tf.float32))
# Add the accuracy to the summary
tf.summary.scalar('Training_Accuracy', accuracy)
# Assign pretrained weights to the AlexNet model
init_fn = tf.contrib.framework.assign_from_values_fn(
alexnet_model.get_map())
return tf.estimator.EstimatorSpec(mode=mode,
predictions=None,
loss=loss,
train_op=train_op,
eval_metric_ops=None,
training_hooks=[RestoreHook(init_fn)])
# Ops for initializing the two different iterators
training_init_op = iterator.make_initializer(tr_data.data)
validation_init_op = iterator.make_initializer(val_data.data)
# TF placeholder for graph input and output
if mode == 'alexnet' or mode == 'resnet':
x = tf.placeholder(tf.float32, [None, img_size[0], img_size[1], 3])
elif mode == 'densenet':
x = Input(shape=(img_size[0], img_size[1], 3), name='data')
y = tf.placeholder(tf.float32, [None, num_classes])
keep_prob = tf.placeholder(tf.float32)
global_step = tf.Variable(0, trainable=False)
# Initialize model
if mode == 'alexnet':
model = AlexNet(x, keep_prob, num_classes, train_layers)
score = model.fc8
elif mode == 'densenet':
model_op = DenseNet(sub_mode, x, num_classes=num_classes)
model = model_op.create()
score = model_op.output
elif mode == 'resnet':
model_op = ResNet(resnet_size=sub_mode, num_classes=num_classes, resnet_version=1)
score = model_op.create(x, True)
# List of trainable variables of the layers we want to train
if 'all' in train_layers:
var_list = tf.trainable_variables()
else:
var_list = [v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers]