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
