**kwargs)
test_loader = torch.utils.data.DataLoader(datasets.CIFAR10(
'../',
train=False,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.491399689874, 0.482158419622, 0.446530924224),
(0.247032237587, 0.243485133253, 0.261587846975))
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
# get the model and convert it into cuda for if necessary
net = model.SqueezeNet()
if args.model_name is not None:
print("loading pre trained weights")
pretrained_weights = torch.load(args.model_name)
net.load_state_dict(pretrained_weights)
if args.cuda:
net.cuda()
#print(net)
# create optimizer
# using the 55 epoch learning rule here
def paramsforepoch(epoch):
p = dict()
regimes = [[1, 18, 5e-3, 5e-4], [19, 29, 1e-3, 5e-4], [30, 43, 5e-4, 5e-4],
def main():
np.random.seed(45)
nb_class = 2
width, height = 224, 224
sn = model.SqueezeNet(nb_classes=nb_class, inputs=(3, height, width))
print('Build model')
sgd = SGD(lr=0.001, decay=0.0002, momentum=0.9, nesterov=True)
sn.compile(
optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
print(sn.summary())
# Training
train_data_dir = 'data/train'
validation_data_dir = 'data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
nb_epoch = 500
# Generator
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
#train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(width, height),
batch_size=32,
class_mode='categorical')
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(width, height),
batch_size=32,
class_mode='categorical')
# Instantiate AccLossPlotter to visualise training
plotter = AccLossPlotter(graphs=['acc', 'loss'], save_graph=True)
early_stopping = EarlyStopping(monitor='val_loss', patience=3, verbose=0)
checkpoint = ModelCheckpoint(
'weights.{epoch:02d}-{val_loss:.2f}.h5',
monitor='val_loss',
verbose=0,
save_best_only=True,
save_weights_only=True,
mode='min',
period=1)
sn.fit_generator(
train_generator,
samples_per_epoch=nb_train_samples,
nb_epoch=nb_epoch,
validation_data=validation_generator,
nb_val_samples=nb_validation_samples,
callbacks=[plotter, checkpoint])
sn.save_weights('weights.h5')
def main():
parser = argparse.ArgumentParser(description="SqueezeNet example.")
parser.add_argument("--batch-size",
type=int,
default=32,
dest='batchsize',
help="Size of the mini batch. Default: 32.")
parser.add_argument("--action",
type=str,
default='train',
help="Action to be performed, train/predict")
parser.add_argument("--epochs",
type=int,
default=20,
help="Number of epochs, default 20.")
parser.add_argument("--lr",
type=float,
default=0.001,
help="Learning rate of SGD, default 0.001.")
parser.add_argument("--epsilon",
type=float,
default=1e-8,
help="Epsilon of Adam epsilon, default 1e-8.")
parser.add_argument("-p",
"--path",
type=str,
default='.',
required=True,
help="Path where the images are. Default: $PWD.")
parser.add_argument("-v",
"--val-path",
type=str,
default='.',
dest='valpath',
help="Path where the val images are. Default: $PWD.")
parser.add_argument("--img-width",
type=int,
default=224,
dest='width',
help="Rows of the images, default: 224.")
parser.add_argument("--img-height",
type=int,
default=224,
dest='height',
help="Columns of the images, default: 224.")
parser.add_argument("--channels",
type=int,
default=3,
help="Channels of the images, default: 3.")
args = parser.parse_args()
sgd = SGD(lr=args.lr, decay=0.0002, momentum=0.9)
t0 = time.time()
if args.action == 'train':
train_generator = dp.train_data_generator(args.path, args.width,
args.height)
validation_generator = dp.val_data_generator(args.valpath, args.width,
args.height)
classes = train_generator.class_indices
nb_train_samples = train_generator.nb_sample
nb_val_samples = validation_generator.nb_sample
print("[squeezenet_demo] N training samples: %i " % nb_train_samples)
print("[squeezenet_demo] N validation samples: %i " % nb_val_samples)
nb_class = train_generator.nb_class
print('[squeezenet_demo] Total classes are %i' % nb_class)
t0 = print_time(t0, 'initialize data')
model = km.SqueezeNet(nb_class,
inputs=(args.channels, args.height, args.width))
# dp.visualize_model(model)
t0 = print_time(t0, 'build the model')
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
t0 = print_time(t0, 'compile model')
model.fit_generator(train_generator,
samples_per_epoch=nb_train_samples,
nb_epoch=args.epochs,
validation_data=validation_generator,
nb_val_samples=nb_val_samples)
t0 = print_time(t0, 'train model')
model.save_weights('./weights.h5', overwrite=True)
model_parms = {
'nb_class': nb_class,
'nb_train_samples': nb_train_samples,
'nb_val_samples': nb_val_samples,
'classes': classes,
'channels': args.channels,
'height': args.height,
'width': args.width
}
write_json(model_parms, fname='./model_parms.json')
t0 = print_time(t0, 'save model')
elif args.action == 'predict':
_parms = parse_json('./model_parms.json')
model = km.SqueezeNet(_parms['nb_class'],
inputs=(_parms['channels'], _parms['height'],
_parms['width']),
weights_path='./weights.h5')
dp.visualize_model(model)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
X_test, Y_test, classes, F = dp.prepare_data_test(
args.path, args.width, args.height)
t0 = print_time(t0, 'prepare data')
outputs = []
results = model.predict(X_test, batch_size=args.batchsize, verbose=1)
classes = _parms['classes']
for i in range(0, len(F)):
_cls = results[i].argmax()
max_prob = results[i][_cls]
outputs.append({'input': F[i], 'max_probability': max_prob})
cls = [key for key in classes if classes[key] == _cls][0]
outputs[-1]['class'] = cls
print('[squeezenet_demo] %s: %s (%.2f)' % (F[i], cls, max_prob))
t0 = print_time(t0, 'predict')
#Creating the dataset
dataset = ld.Roads()
training_set, test_set = dataset.load_data()
#Habilitando GPU
if torch.cuda.is_available():
device = torch.device("cuda:0")
print("Rodando na GPU")
else:
device = torch.device("cpu")
print("Rodando na CPU")
#Creating the model
model = model.SqueezeNet().to(device)
# print(model)
#Função utilizada para realizar a inicialização dos pesos da camadas
#convolucionais seguindo distribuição normal com média 0
def _initialize_weights(net):
for m in net.modules():
if isinstance(m, nn.Conv2d):
m.weight.data.normal_(mean=0, std=0.02)
model.apply(_initialize_weights)
model.cuda()
summary(model, (3, 512, 512))
#Setting the optimizer and loss
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
loss_function = nn.BCELoss()
x_t = np.zeros((50000, 3, 224, 224))
for i, img in enumerate(x_train):
im = img.reshape((32, 32, 3))
large_img = cv2.resize(im, dsize=(224, 224), interpolation=cv2.INTER_CUBIC)
x_t[i] = large_img.reshape((3, 224, 224))
#for i in range(0,5000)
x_te = np.zeros((50000, 3, 224, 224))
for i, img in enumerate(x_test):
im = img.reshape((32, 32, 3))
large_img = cv2.resize(im, dsize=(224, 224), interpolation=cv2.INTER_CUBIC)
x_te[i] = large_img.reshape((3, 224, 244))
t0 = time.time()
nb_class = 10
#out = Lambda(lambda image: tf.image.resize_images(image, (2,224, 224)))(inp)
model = km.SqueezeNet(nb_class, inputs=(3, 224, 224))
# dp.visualize_model(model)
t0 = print_time(t0, 'build the model')
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
t0 = print_time(t0, 'compile model')
#model.fit_generator(train_generator,samples_per_epoch=nb_train_samples,nb_epoch=args.epochs,validation_data=validation_generator,nb_val_samples=nb_val_samples)
model.fit(x_t,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_te, y_test),
shuffle=True)
def main(args):
print(platform.python_version())
if args.reset_training:
print(
"resetting training by removing all weights without saving previous training"
)
just_empty_folder()
if args.new_training:
print("moving contents of folder to new location")
empty_folder_and_move()
np.random.seed(45)
nb_class = 451 #found by doing: echo */ | wc
width, height = 224, 224
bat_size = BATCH_SIZE
#structure
sn = model.SqueezeNet(nb_classes=nb_class, inputs=(3, height, width))
#multi-gpu
# local_devices = device_lib.list_local_devices()
# num_gpus = len([dev.name for dev in local_devices if dev.device_type == 'GPU'])
# print(num_gpus)
# if(num_gpus >= 2):
# sn = multi_gpu_model(sn, num_gpus)
# print('build model')
#obviously mess around with the hyperparameters
#sgd = SGD(lr = .001, decay=.0002, momentum=.9, nesterov=True)
num_files = 0
saved_model, current_epoch_num = find_most_recent_model()
print("saved model: " + saved_model +
"current epoch: {}".format(current_epoch_num))
if len(saved_model) > 0 and current_epoch_num != 0:
sn = load_model(saved_model)
##potential issue: adam may reset previous history, may need to use a different optimizer
sn.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
print(sn.summary)
training_dir = '/kw_resources/food/dataset/training_data/'
validation_dir = '/kw_resources/food/dataset/testing_data/'
num_training = 166580 #used find . -type f | wc -l for each directory
num_validation = 60990
num_epochs = int(args.nb_epochs)
bat_size = int(args.batch_size)
if current_epoch_num > num_epochs:
print("already trained for {} epochs".format(current_epoch_num))
exit()
else:
num_epochs = num_epochs - current_epoch_num
print("number of epochs to train for: {}".format(num_epochs))
#generation
training_generator_parameters = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
testing_generator_parameters = ImageDataGenerator(rescale=1. / 255)
train_data = training_generator_parameters.flow_from_directory(
training_dir,
target_size=(width, height),
batch_size=bat_size,
class_mode='categorical')
validation_data_generator = testing_generator_parameters.flow_from_directory(
validation_dir,
target_size=(width, height),
batch_size=bat_size,
class_mode='categorical')
#checkpoint
filepath = FILEPATH + "weights-{epoch:02d}-{val_acc:.2f}.h5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=False,
save_weights_only=False,
mode='max')
callbacks_list = [checkpoint]
#fitting
sn.fit_generator(train_data,
steps_per_epoch=(num_training // bat_size),
epochs=num_epochs,
validation_data=validation_data_generator,
validation_steps=(num_validation // bat_size),
callbacks=callbacks_list,
verbose=1)
#save history to use at a later time
history = sn
with open(
'/kw_resources/food/results/e:{}_b:{}_{}'.format(
num_epochs, bat_size,
datetime.datetime.now().strftime('%m-%d-%X')), 'wb') as f:
pickle.dump(history.history, f)
loader_train = DataLoader(train_data,
batch_size=BATCH_SIZE,
sampler=sampler.SubsetRandomSampler(
range(NUM_TRAIN)),
drop_last=True)
loader_val = DataLoader(train_data,
batch_size=BATCH_SIZE,
sampler=sampler.SubsetRandomSampler(
range(NUM_TRAIN, NUM_TRAIN + NUM_VAL)))
loader_test = DataLoader(test_data, batch_size=BATCH_SIZE)
dtype = torch.float32
device = torch.device('cpu')
epoch = 0
loss_list = []
val_acc_list = []
best_accuracy = 0.0
neuralNet = model.SqueezeNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(neuralNet.parameters(), lr=0.001, momentum=0.9)
for epoch in range(epochCount):
print("Epoch {}".format(epoch))
train(epoch)
validate(epoch)
print("\t-----------------")
print(loss_list)
optimizer='adam',
metrics=['accuracy'])
return model
# build the model
# model = baseline_model()
#Xception
# model = tiny_XCEPTION((img_h, img_w, img_d), 2, l2_regularization=0.01)
# model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
#Squeezznet
sgd = SGD(lr=0.001, decay=0.0002, momentum=0.9, nesterov=True)
model = sn.SqueezeNet(2, inputs=(3, 224, 224))
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
# Fit the model
print('Training the CNN ...')
graph = plot_model(model, to_file='model.png', show_shapes=True)
model.fit(X,
Y,
validation_data=(X_val, Y_val),
nb_epoch=15,
batch_size=100,
verbose=2)
#model.fit(X1, Y1, nb_epoch=10, batch_size=30, verbose=2)
# Final evaluation of the model