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
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())
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 + '_' +
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]