def CreateResNet(self, input_shape): from resnet50 import ResNet50 resnet = ResNet50(include_top = False, weights='imagenet', input_shape = input_shape) return resnet
labels = np.ones((num_of_samples,),dtype='int64') labels[0:419]=0 labels[420:719]=1 names = ['cars','bikes'] # convert class labels to on-hot encoding Y = np_utils.to_categorical(labels, num_classes) x,y = shuffle(img_data,Y, random_state=2) X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=2) image_input = Input(shape=(224, 224, 3)) model = ResNet50(weights='imagenet',include_top=False) model.summary() last_layer = model.output # add a global spatial average pooling layer x = GlobalAveragePooling2D()(last_layer) # add fully-connected & dropout layers x = Dense(512, activation='relu',name='fc-1')(x) x = Dropout(0.5)(x) x = Dense(256, activation='relu',name='fc-2')(x) x = Dropout(0.5)(x) out = Dense(num_classes, activation='softmax',name='output_layer')(x) # model to train custom_resnet_model = Model(inputs=model.input, outputs=out) custom_resnet_model.summary()
X_train = np.uint8(augmented_Xtrain) y_train = np.int32(y_train_labels) else: X_train = X_train y_train = y_train # training_model 1 for VGGFace 2 for VGG16 im_shape = (224, 224, 3) image_input = Input(shape=im_shape) ############################################################################## # RESNET 50 ############################################################################## if training_model == "ResNet50": base_resnet = ResNet50(weights='imagenet', include_top=False, pooling='avg') x = base_resnet.layers[-1] out = Dense(units=nb_classes, activation='softmax', name='output', use_bias=True, kernel_initializer=initializers.random_normal(mean=0.0, stddev=0.01), kernel_regularizer=regularizers.l2(0.001), bias_initializer='zeros', bias_regularizer=regularizers.l2(0.001))(x.output) custom_resnet_model = Model(inputs=base_resnet.input, outputs=out) for layer in custom_resnet_model.layers: layer.trainable = True
from resnet50 import ResNet50 from keras.preprocessing import image from imagenet_utils import decode_predictions, preprocess_input import numpy as np model = ResNet50(include_top=True, weights='imagenet') img_path = 'images/mf.jpg' 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) preds = model.predict(x) print('Predicted:', decode_predictions(preds))
img_path = 'data/%d.tif' % file_idx csv_path = 'data/%d.csv' % file_idx def pop_layer(model): if not model.outputs: raise Exception('Sequential model cannot be popped: model is empty.') model.layers.pop() if not model.layers: model.outputs = [] model.inbound_nodes = [] model.outbound_nodes = [] else: model.layers[-1].outbound_nodes = [] model.outputs = [model.layers[-1].output] model.built = False input_shape = (224, 224, 3) img_input = Input(shape=input_shape) base_model = ResNet50(weights='imagenet',input_tensor=img_input) pop_layer(base_model) x = Dense(1, activation='softmax', name='fc1')(base_model.layers[-1].output) print "New model defined" model = Model(img_input, x) print "New model compiled" model.compile(loss='mean_squared_error',optimizer='sgd',metrics=['accuracy']) print "Fit generator" model.fit_generator(generate_data(),samples_per_epoch=20,nb_epoch=100,verbose=2) model.save('custom_resnet.h5')
#Put data into trainloader, specify batch_size train_loader = torch.utils.data.DataLoader(train_data, batch_size=128, shuffle=True, num_workers=2) validation_loader = torch.utils.data.DataLoader(validation_data, batch_size=100, shuffle=True, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') #Function to show CIFAR images def show_data(image): plt.imshow(np.transpose(image[0], (1, 2, 0)), interpolation='bicubic') plt.show() #show_data(train_data[0]) #Need to import model a model model = ResNet50() #model = ResNet34() #model = CNN_batch() #Pass model to GPU model = model.to(device) model.train() optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9, weight_decay=5e-4) criterion = nn.CrossEntropyLoss() length_train = len(train_data) length_validation = len(validation_data) #print(length_train) #print(len(train_loader)) num_classes = 10 #Training
model = VGG16(weights='imagenet', include_top=False) model.summary() model.layers[-1].get_config() img_path = 'elephant.jpeg' 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) features = model.predict(x) #%% model = ResNet50(include_top=False,weights='imagenet') model.summary() model.layers[-1].get_config() img_path = 'elephant.jpeg' 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) # preds = model.predict(x) print('Predicted:', decode_predictions(preds)) ## print: [[u'n02504458', u'African_elephant']] # ##%% model = ResNet50(include_top=False,weights='imagenet') model.summary()
def proc(taskFile, rootDir, atOnce=10000): good = list() bad = list() ugly = list() interesting = set() count = 0 im = 0 model = ResNet50(weights='imagenet') for x in ['car', 'pickup', 'suv', 'truck', 'crossover', 'van', 'minivan', 'sports_car', 'cab', 'racer', 'convertible', 'jeep', 'ambulance']: interesting.add(x) data = readTasking(taskFile) startTime = time.time() for d in data: img_path = '{0}/{1}'.format(rootDir, d['filename']) flag = True try: img = image.load_img(img_path, target_size=(224, 224)) except: # ugly this is not a decodable image ugly.append(d) flag = False if flag: x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) predictions = decode_predictions(preds)[0][:4] found = False for prediction in predictions: i, t, score = prediction if t in interesting: # image was interesting good.append((d, t)) found = True break if not found: # image was not interesting bad.append((d, predictions[0][1])) if count == atOnce: count = 0 endTime = time.time() - startTime im = im + 1 print('processed:', im * atOnce, 'Images', 'good', len(good), 'bad', len(bad), 'file', len(file), endTime) startTime = time.time() count = count + 1 return (good, bad, ugly)
def train_model(): parser = argparse.ArgumentParser() parser.add_argument( '--dataset', '-D', default='../../data/cowc_processed/train_val/crop', help= 'Path to directory containing train.txt, val.txt, mean.npy and train/val directories' ) parser.add_argument('--insize', '-i', default=96, type=int, help='Input size to CNN') parser.add_argument('--car-max', '-M', type=int, default=9, help='Max car number to count') parser.add_argument( '--use-class-weight', '-w', action='store_true', help='Use class weight when compute softmax cross entropy loss') parser.add_argument('--batchsize', '-b', type=int, default=32, help='Number of images in each mini-batch') parser.add_argument('--test-batchsize', '-B', type=int, default=256, help='Number of images in each test mini-batch') parser.add_argument('--gpu', '-g', type=int, default=0, help='GPU ID (negative value indicates CPU)') parser.add_argument('--epoch', '-e', type=int, default=80, help='Number of sweeps over the dataset to train') parser.add_argument( '--lr-shift', type=float, nargs='*', default=[0.5, 0.75], help='Points to shift learning rate exponentially by 0.1') parser.add_argument( '--lr', type=float, default=0.01, help='Initial leraning rate used in MomentumSGD optimizer') parser.add_argument( '--caffemodel', '-c', default=None, help= 'Path to ResNet50 caffemodel file to load weights. If None, train from scratch' ) parser.add_argument('--frequency', '-f', type=int, default=1, help='Frequency of taking a snapshot') parser.add_argument( '--out', '-o', default='logs', help='Directory to output the result under "models" directory') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--noplot', dest='plot', action='store_false', help='Disable PlotReport extension') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') log_dir = os.path.join("../../models", args.out) writer = SummaryWriter(log_dir=log_dir) # Compute class_weight used in softmax cross entropy if args.use_class_weight: histogram = np.load(os.path.join(args.dataset, "histogram.npy")) class_weight = compute_class_weight(histogram, args.car_max) if args.gpu >= 0: class_weight = cuda.cupy.asarray(class_weight, dtype=cuda.cupy.float32) else: class_weight = None # Set up a neural network to train # Classifier reports softmax cross entropy loss and accuracy at every # iteration, which will be used by the PrintReport extension below. model = ResNet50(args.car_max + 1, args.insize, class_weight=class_weight, caffemodel_path=args.caffemodel) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU # Setup an optimizer optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) optimizer.setup(model) # Load mean image mean = np.load(os.path.join(args.dataset, "mean.npy")) # Load the MNIST dataset train_root = os.path.join(args.dataset, "train") val_root = os.path.join(args.dataset, "val") train = CowcDataset_Counting(os.path.join(args.dataset, "train.txt"), train_root, args.insize, mean=mean, random_crop=True, random_flip=True, random_color_distort=True, label_max=args.car_max) test = CowcDataset_Counting(os.path.join(args.dataset, "val.txt"), val_root, args.insize, mean=mean, random_crop=False, random_flip=False, random_color_distort=False, label_max=args.car_max) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.test_batchsize, repeat=False, shuffle=False) # Set up a trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=log_dir) # Evaluate the model with the test dataset for each epoch trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. trainer.extend(extensions.dump_graph('main/loss')) # Take a snapshot for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch')) # Save trained model for each specific epoch trainer.extend(extensions.snapshot_object( model, 'model_iter_{.updater.iteration}'), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport()) # Decay learning rate at some epochs if len(args.lr_shift) > 0: lr_shift = [ int(shift_point * args.epoch) for shift_point in args.lr_shift ] trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=triggers.ManualScheduleTrigger( lr_shift, 'epoch')) # Monitor learning rate at every iteration trainer.extend(extensions.observe_lr(), trigger=(1, 'iteration')) # Save two plot images to the result dir if args.plot and extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png')) # Print selected entries of the log to stdout # Here "main" refers to the target link of the "main" optimizer again, and # "validation" refers to the default name of the Evaluator extension. # Entries other than 'epoch' are reported by the Classifier link, called by # either the updater or the evaluator. trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'lr', 'elapsed_time' ])) # Print a progress bar to stdout trainer.extend(extensions.ProgressBar()) # Write training log to TensorBoard log file trainer.extend( TensorboardLogger(writer, [ 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'lr' ])) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run()
from keras.preprocessing.image import img_to_array from keras.preprocessing.image import load_img from sklearn.model_selection import train_test_split import pandas as pd import numpy as np from pathos.helpers.mp_helper import random_state from keras.layers import Flatten, Dense from keras.models import Model import cv2 inputShape = (197, 197) preprocess = imagenet_utils.preprocess_input print("Loading ResNet50...") model = ResNet50(weights='imagenet', include_top=False, input_shape=(197, 197, 3)) for layer in model.layers: layer.trainable = False ##model.layers.pop() ##model.layers[-1].outbound_nodes = [] ##model.outputs = [model.layers[-1].output] output = model.get_layer('avg_pool').output output = Flatten()(output) output = Dense(activation="relu", units=1000)(output) # your newlayer Dense(...) output = Dense(activation="relu", units=500)(output) output = Dense(activation="relu", units=250)(output) output = Dense(activation="relu", units=100)(output) output = Dense(activation="relu", units=50)(output)
pprint(args.__dict__, width=1) #set random seed torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) model = util.build_model(args) model = model.cpu() # load dataset data = datasets.get_dataset(args.dataset_root, args.dataset, args.batch_size, args.cuda, args.aug, in_memory=args.in_memory, input_size=args.input_size) train_dataset, train_loader, test_dataset, test_loader = data # teacher model teacher = ResNet50() teacher.load_state_dict(torch.load(args.teacher_path)) teacher.cuda() wrapped_model = ModelRefineryWrapper(model, teacher) if args.cuda: model = model.cuda() print(model) print(util.num_nonzeros(model)) print('Target Nonzeros:', util.target_nonzeros(model)) train_model(wrapped_model, model, args.save_path, train_loader, test_loader, args.lr, args.epochs, args)
def main(args=None): K.tensorflow_backend.set_session(get_session()) # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) if args.model=='blurmapping': t_size=96 elif args.model=='vgg16': t_size=64 else: t_size=224 # data_path = args.data_dir # data_dir_list = os.listdir(data_path) img_data_list = [] if args.usepkldata==False: with open('./data/img_list.pkl', 'rb') as pk: img_list = _pickle.load(pk) for img in img_list: # img_path = data_path + '/' + dataset + '/' + img img_path = args.data_dir+'/'+img+'.jpg' img = image.load_img(img_path, target_size=(t_size,t_size)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) print('Input image shape:', x.shape) img_data_list.append(x) img_data = np.array(img_data_list) # img_data = img_data.astype('float32') print(img_data.shape) img_data = np.rollaxis(img_data, 1, 0) print(img_data.shape) img_data = img_data[0] print(img_data.shape) with open('./data/img_data'+str(t_size)+'.pkl', 'wb') as pk: _pickle.dump(img_data, pk) else: with open('./data/img_data'+str(t_size)+'.pkl', 'rb') as pk: img_data = _pickle.load(pk) print(img_data.shape) num_classes = 2 num_of_samples = img_data.shape[0] if args.object =='focus': with open('./data/focus.pkl', 'rb') as pk: labels = _pickle.load(pk) elif args.object == 'quality': with open('./data/quality.pkl', 'rb') as pk: labels = _pickle.load(pk) datagen = ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) datagen.fit(img_data) names = ['bad', 'good'] # convert class labels to on-hot encoding Y = np_utils.to_categorical(labels, num_classes) # Y = labels # encoder = LabelEncoder() # encoder.fit(Y) # encoded_Y = encoder.transform(Y) # Shuffle the dataset x, y = shuffle(img_data, Y, random_state=2) # Split the dataset X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=2) ########################################################################################################################### if args.model=='resnet': # Training the classifier alone image_input = Input(shape=(224, 224, 3)) model = ResNet50(input_tensor=image_input, weights='imagenet') model.summary() last_layer = model.get_layer('avg_pool').output x = Flatten(name='flatten')(last_layer) x = Dense(1000, activation='relu', name='fc1')(x) x = Dropout(0.5)(x) out = Dense(num_classes, activation='softmax', name='output_layer')(x) custom_resnet_model = Model(inputs=image_input, outputs=out) custom_resnet_model.summary() for layer in custom_resnet_model.layers[:-1]: layer.trainable = False custom_resnet_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[f1_score,'accuracy']) t = time.time() filepath = "./data/resnet-"+str(args.object)+"-{epoch:02d}-{val_acc:.2f}.h5" checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint] # hist = custom_resnet_model.fit(X_train, y_train, batch_size=32, epochs=args.epochs, verbose=1, # validation_data=(X_test, y_test), # callbacks=callbacks_list) Y = np_utils.to_categorical(labels, num_classes) hist = custom_resnet_model.fit_generator(datagen.flow(img_data, Y, batch_size=32),callbacks=callbacks_list, steps_per_epoch=len(img_data) / 32, epochs=1000) print('Training time: %s' % (t - time.time())) (loss, accuracy) = custom_resnet_model.evaluate(X_test, y_test, batch_size=args.batch_size, verbose=1) print("[INFO] loss={:.4f}, accuracy: {:.4f}%".format(loss, accuracy * 100)) ######################################################################################### elif args.model=='vgg16': # Custom_vgg_model_1 # Training the classifier alone # image_input = Input(shape=(224, 224, 3)) Y = labels encoder = LabelEncoder() encoder.fit(Y) encoded_Y = encoder.transform(Y) # Shuffle the dataset x, y = shuffle(img_data, encoded_Y, random_state=2) # Split the dataset X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=2) vgg_model = VGG16( include_top=False, weights='imagenet') for layer in vgg_model.layers[:-1]: layer.trainable = False inp = Input(shape=(64, 64, 3), name='input_image') output_vgg_conv = vgg_model(inp) x_1 = Flatten(name='flatten')(output_vgg_conv) x_1 = Dense(512, activation='relu', name='fc1')(x_1) x_1 = Dropout(0.5)(x_1) x_1 = Dense(128, activation='relu', name='fc2')(x_1) x_1 = Dropout(0.25)(x_1) x_1 = Dense(8, activation='relu', name='fc3')(x_1) x_1 = Dropout(0.125)(x_1) x_1 = Dense(1, activation='sigmoid', name='frontalpred')(x_1) custom_vgg_model = Model(input=inp, output=x_1) custom_vgg_model.summary() filepath = "./data/vgg16-"+str(args.object)+"-{epoch:02d}-{val_acc:.2f}.h5" checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint] custom_vgg_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[f1_score,'accuracy']) t = time.time() # t = now() hist = custom_vgg_model.fit(X_train, y_train, batch_size=32, epochs=args.epochs, verbose=1, validation_data=(X_test, y_test), callbacks=callbacks_list) print('Training time: %s' % (t - time.time())) (loss, accuracy) = custom_vgg_model.evaluate(X_test, y_test, batch_size=args.batch_size, verbose=1) print("[INFO] loss={:.4f}, accuracy: {:.4f}%".format(loss, accuracy * 100)) elif args.model=='blurmapping': model = KitModel(weight_file='blurMapping.npy') model.summary() last_layer = model.get_layer('relu5_3').output x = Flatten(name='flatten')(last_layer) x = Dense(1024, activation='relu', name='fc_1')(x) x = Dropout(0.5)(x) x = Dense(128, activation='relu', name='fc2')(x) x = Dropout(0.25)(x) out = Dense(num_classes, activation='softmax', name='output_layer')(x) custom_model = Model(inputs=model.input, outputs=out) custom_model.summary() for layer in custom_model.layers[:-1]: layer.trainable = False filepath = "./data/blurmapping-"+str(args.object)+"-{epoch:02d}-{val_acc:.2f}.h5" checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint] custom_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[f1_score,'accuracy']) t = time.time() # t = now() # hist = custom_model.fit(X_train, y_train, batch_size=32, epochs=args.epochs, verbose=1, # validation_data=(X_test, y_test), # callbacks=callbacks_list) Y = np_utils.to_categorical(labels, num_classes) hist = custom_model.fit_generator(datagen.flow(img_data, Y, batch_size=args.batch_size),callbacks=callbacks_list, steps_per_epoch=1000, epochs=50) print('Training time: %s' % (t - time.time()))
if NUM_CLASSES == None: NUM_CLASSES = dataset_train.get_number_of_classes() NUM_TRAIN_SAMPLES = dataset_train.get_number_of_samples() NUM_TEST_SAMPLES= dataset_test.get_number_of_samples() print(f"train_samples {NUM_TRAIN_SAMPLES} test_samples {NUM_TEST_SAMPLES}") print(f'num_classes {NUM_CLASSES}') NUM_EPOCHS = 10000 BATCH_SIZE = 8 LEARNING_RATE = 1e-4 #DEVICE = 'cuda' DEVICE = 'cpu' model_resnet = ResNet50(class_num = NUM_CLASSES).to(DEVICE) optimizer = torch.optim.Adam(params = model_resnet.parameters(), lr = LEARNING_RATE) def layers_debug(optim): layer_count = 0 for var_name in optim.state_dict(): shape = optim.state_dict()[var_name].shape if len(optim.state_dict()[var_name].shape)>1: layer_count += 1 print(f"{var_name}\t\t{optim.state_dict()[var_name].shape}") print(layer_count) layers_debug(model_resnet)
assert batch_x.shape == (batch_size, 32, 32, 3) # print("idx =", self.idx) return batch_x, batch_y def test(self): return self.X_test, self.y_test # data cifar10 = Cifar10() valid_x, valid_y = cifar10.test() valid_x, valid_y = tf.convert_to_tensor(valid_x), tf.convert_to_tensor(valid_y) batch_size = 512 # build model data_format = "channels_last" model = ResNet50(data_format, classes=10) optimizer = tf.train.AdamOptimizer() # EPOCHS = 10 for i in range(EPOCHS): print("EPOCHS:", i) while(True): batch_x, batch_y = cifar10.next_batch(batch_size) if batch_x == batch_y == None: break batch_x, batch_y = tf.convert_to_tensor(batch_x), tf.convert_to_tensor(batch_y) # train with tf.GradientTape() as tape: logits = model(batch_x) loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
num_epochs=configs['num_epochs'] data_path='data/HARRISON/preprocessed_data/' # image_path='/home/eric/data/social_images/' image_path='/home/eric/data/HARRISON/' model_name='resnet50' object_image_features_filename='resnet50_image_name_to_features.h5' generator=Generator(data_path=data_path,batch_size=batch_size,image_features_filename=object_image_features_filename) config = tf.ConfigProto() config.gpu_options.allocator_type = 'BFC' config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) # model=VGGNet.vgg(input_shape=(224,224,3),classes=generator.VOCABULARY_SIZE) model=ResNet50.resnet(input_shape=(configs['img_width'],configs['img_height'],configs['channel']), classes=generator.VOCABULARY_SIZE) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=["accuracy",fmeasure,precision,recall]) print(model.summary()) plot_model(model,show_shapes=True,to_file=model_name+'.png') save_path=os.path.join('trained_model',model_name) if(not os.path.exists(save_path)): os.makedirs(save_path) model_names = (os.path.join(save_path,'hashtag_weights.{epoch:02d}-{val_loss:.4f}.hdf5')) model_checkpoint = ModelCheckpoint(filepath=model_names, monitor='val_loss',verbose=1, save_best_only=True, mode='max') callbacks = [model_checkpoint] num_training_samples = generator.training_dataset.shape[0] num_validation_samples = generator.validation_dataset.shape[0] print('Number of training samples:', num_training_samples)
from resnet50 import ResNet50 from keras.preprocessing import image from imagenet_utils import preprocess_input, decode_predictions import numpy as np model = ResNet50(weights='imagenet') img_path = '/Users/dadesheng/Workspace/Assignment3/411a3/train/00027.jpg' 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) preds = model.predict(x) print('Predicted:', decode_predictions(preds))
## 在这里,我是直接手动下载了预训练文件resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5, ## 然后又找到resnet50.py将其与权重文件一起放在这里;如果希望电脑自动下载预训练文件,可以直接把 ## 下面的from resnet50 import ResNet50注释掉,解掉上面的那行注释 from resnet50 import ResNet50 from keras.models import Sequential from keras.utils.vis_utils import plot_model from keras.layers import Conv2D, Dense, MaxPool2D, Flatten, Dropout from keras.optimizers import Adam, SGD from keras.preprocessing import image import numpy as np import matplotlib.pyplot as plt import multiprocessing # 实例化网络结构 resnet_50 = ResNet50(include_top=False, weights='imagenet', input_shape=(224, 224, 3)) top_model = Sequential() top_model.add(Flatten(input_shape=resnet_50.output_shape[1:], name='flatten')) top_model.add(Dense(units=256, activation='relu', name='fc1')) top_model.add(Dropout(rate=0.5, name='dropout1')) top_model.add(Dense(units=54, activation='softmax', name='output_0')) # 将两者拼接起来 model = Sequential() model.add(resnet_50) model.add(top_model) # 模型的结构图:因为是拼接的,所以只会显示两层 # plot_model(model, to_file='resnet_50.png', show_shapes=True)
vertical_flip=False,# randomly flip images rescale = 1./255) datagen.fit(X_train) # Binary classification task; patient is operated on([1 0]) or not([0 1]) num_classes = 2 image_input = Input(shape=(224, 224, 3)) ########################################################################################################################### # augmented_resnet_model_1 #Replaced dense output layer of 1000 classes with a dense layer of 2 classes. Also, added a dropout layer between flatten and output layer. # Load standard ResNet50 model model = ResNet50(input_tensor=image_input, include_top=True,weights='imagenet') model.summary() # Modify softmax dense layer and add dropout layer last_layer = model.get_layer('avg_pool').output x= Flatten(name='flatten')(last_layer) x = Dropout(0.5)(x) out = Dense(num_classes, activation='softmax', name='output_layer')(x) # Create custom resnet model augmented_model = Model(inputs=image_input,outputs= out) augmented_model.summary() # Freeze the imagenet weights of all layers except newly modified layer for layer in augmented_model.layers[:-1]: layer.trainable = False
def RetinaNet(input_shape=None, n_classes=None, training=False): H = W = input_shape num_anchors = get_anchors(input_shape=H).shape[0] loss_fn = LossV2(n_classes=n_classes) base_model = ResNet50(input_shape=[H, W, 3], weights='imagenet', include_top=False) resnet_block_output_names = [ 'activation_21', 'activation_39', 'activation_48' ] resnet_block_outputs = { 'C{}'.format(idx + 3): base_model.get_layer(layer).output for idx, layer in enumerate(resnet_block_output_names) } resnet_block_outputs = { level: conv_block(tensor, 256, 1, name=level + '_1x1') for level, tensor in resnet_block_outputs.items() } P5 = resnet_block_outputs['C5'] P6 = conv_block(base_model.get_layer('activation_48').output, 256, 3, strides=2, name='P6') P6_relu = tf.keras.layers.ReLU(name='P6')(P6) P7 = conv_block(P6_relu, 256, 3, strides=2, name='P7') M4 = tf.keras.layers.add([ tf.keras.layers.Lambda(Upsampling, arguments={'scale': 2}, name='P5_UP')(P5), resnet_block_outputs['C4'] ], name='P4_merge') M3 = tf.keras.layers.add([ tf.keras.layers.Lambda(Upsampling, arguments={'scale': 2}, name='P4_UP')(M4), resnet_block_outputs['C3'] ], name='P3_merge') P4 = conv_block(M4, 256, 3, name='P4') P3 = conv_block(M3, 256, 3, name='P3') pyrammid_features = [P3, P4, P5, P6, P7] classification_subnet = build_classification_subnet(n_classes=n_classes) regression_subnet = build_regression_subnet() classification_outputs = [ classification_subnet(level) for level in pyrammid_features ] regression_outputs = [ regression_subnet(level) for level in pyrammid_features ] classification_head = tf.keras.layers.concatenate( classification_outputs, axis=1, name='classification_head') regression_head = tf.keras.layers.concatenate(regression_outputs, axis=1, name='regression_head') image_input = base_model.input classification_targets = tf.keras.layers.Input(shape=[num_anchors]) regression_targets = tf.keras.layers.Input(shape=[num_anchors, 4]) background_mask = tf.keras.layers.Input(shape=[num_anchors]) ignore_mask = tf.keras.layers.Input(shape=[num_anchors]) Lreg, Lcls, _ = tf.keras.layers.Lambda(loss_fn)([ classification_targets, classification_head, regression_targets, regression_head, background_mask, ignore_mask ]) Lreg = tf.keras.layers.Lambda(lambda x: tf.reshape(x, [-1, 1]), name='box')(Lreg) Lcls = tf.keras.layers.Lambda(lambda x: tf.reshape(x, [-1, 1]), name='focal')(Lcls) if training: _inputs = [ image_input, classification_targets, regression_targets, background_mask, ignore_mask ] _outputs = [Lreg, Lcls] else: _inputs = [image_input] _outputs = [classification_head, regression_head] model = tf.keras.Model(inputs=_inputs, outputs=_outputs, name='RetinaNet') return model