def main():
in_arg = train_utils.get_cmd_args()
dataloaders, class_to_idx = train_utils.transform_data(in_arg.data_dir)
hidden_size = in_arg.hidden_units.split(',')
hidden_size = [int(x) for x in hidden_size]
if in_arg.arch == "vgg16":
arch = {
"model": train_utils.models.vgg16(pretrained=True),
"input_size": 25088,
"name": "vgg16"
}
elif in_arg.arch == "densenet":
arch = {
"model": train_utils.models.densenet161(pretrained=True),
"input_size": 2208,
"name": "densenet"
}
elif in_arg.arch == "alexnet":
arch = {
"model": train_utils.models.alexnet(pretrained=True),
"input_size": 9216,
"name": "alexnet"
}
else:
print("model not available!")
print("Create Model: {} Classifier: {},{},{} Learnrate: {}".format(
arch["name"], arch["input_size"], hidden_size, len(class_to_idx),
in_arg.learning_rate))
model, criterion, optimizer = train_utils.create_model(
arch["model"],
class_to_idx,
input_size=arch["input_size"],
hidden_size=hidden_size,
output_size=len(class_to_idx),
lr=in_arg.learning_rate)
print("Begin Training.. Epochs: {} @{}".format(
in_arg.epochs, "GPU" if in_arg.gpu else "CPU"))
train_utils.train_model(model,
dataloaders["train"],
dataloaders["valid"],
optimizer,
criterion,
epochs=in_arg.epochs,
gpu=in_arg.gpu)
if not os.path.exists(in_arg.save_dir.split('/')[0] + "/"):
os.makedirs(in_arg.save_dir.split('/')[0] + "/")
train_utils.save_model(arch["name"],
model,
optimizer,
criterion,
path=in_arg.save_dir)
def cyclegan_training_loop(dataloader_X, dataloader_Y, test_dataloader_X,
test_dataloader_Y, opts):
"""Runs the training loop.
* Saves checkpoint every opts.checkpoint_every iterations
* Saves generated samples every opts.sample_every iterations
"""
# Create generators and discriminators
G_XtoY, G_YtoX, D_X, D_Y = create_model(opts)
g_params = list(G_XtoY.parameters()) + list(
G_YtoX.parameters()) # Get generator parameters
d_params = list(D_X.parameters()) + list(
D_Y.parameters()) # Get discriminator parameters
# Create optimizers for the generators and discriminators
g_optimizer = optim.Adam(g_params, opts.lr, [opts.beta1, opts.beta2])
d_optimizer = optim.Adam(d_params, opts.lr, [opts.beta1, opts.beta2])
iter_X = iter(dataloader_X)
iter_Y = iter(dataloader_Y)
test_iter_X = iter(test_dataloader_X)
test_iter_Y = iter(test_dataloader_Y)
# Get some fixed data from domains X and Y for sampling. These are images that are held
# constant throughout training, that allow us to inspect the model's performance.
fixed_X = to_var(test_iter_X.next()[0])
fixed_Y = to_var(test_iter_Y.next()[0])
iter_per_epoch = min(len(iter_X), len(iter_Y))
try:
for iteration in range(1, opts.train_iters + 1):
# Reset data_iter for each epoch
if iteration % iter_per_epoch == 0:
iter_X = iter(dataloader_X)
iter_Y = iter(dataloader_Y)
images_X, labels_X = iter_X.next()
images_X, labels_X = to_var(images_X), to_var(
labels_X).long().squeeze()
images_Y, labels_Y = iter_Y.next()
images_Y, labels_Y = to_var(images_Y), to_var(
labels_Y).long().squeeze()
# TRAIN THE DISCRIMINATORS
# Train with real images
d_optimizer.zero_grad()
# Compute the discriminator losses on real images
real_labels = label_ones(images_X.size(0))
D_X_loss = F.mse_loss(D_X(images_X), real_labels)
real_labels = label_ones(images_Y.size(0))
D_Y_loss = F.mse_loss(D_Y(images_Y), real_labels)
d_real_loss = D_X_loss + D_Y_loss
d_real_loss.backward()
d_optimizer.step()
# Train with fake images
d_optimizer.zero_grad()
# Generate fake images that look like domain X based on real images in domain Y
fake_X = G_YtoX(images_Y)
# Compute the loss for D_X
fake_labels = label_zeros(fake_X.size(0))
D_X_loss = F.mse_loss(D_X(fake_X), fake_labels)
# Generate fake images that look like domain Y based on real images in domain X
fake_Y = G_XtoY(images_X)
# Compute the loss for D_Y
fake_labels = label_zeros(fake_Y.size(0))
D_Y_loss = F.mse_loss(D_Y(fake_Y), fake_labels)
d_fake_loss = D_X_loss + D_Y_loss
d_fake_loss.backward()
d_optimizer.step()
# TRAIN THE GENERATORS
# Y--X-->Y CYCLE
g_optimizer.zero_grad()
# Generate fake images that look like domain X based on real images in domain Y
fake_X = G_YtoX(images_Y)
# Compute the generator loss based on domain X
fake_labels = label_ones(fake_X.size(0))
g_loss = F.mse_loss(D_X(fake_X), fake_labels)
reconstructed_Y = G_XtoY(fake_X)
# Compute the cycle consistency loss (the reconstruction loss)
cycle_consistency_loss = torch.abs(
reconstructed_Y - images_Y).sum() / images_Y.size(0)
g_loss += opts.lambda_cycle * cycle_consistency_loss
g_loss.backward()
g_optimizer.step()
# X--Y-->X CYCLE
g_optimizer.zero_grad()
# Generate fake images that look like domain Y based on real images in domain X
fake_Y = G_XtoY(images_X)
# Compute the generator loss based on domain Y
fake_labels = label_ones(fake_Y.size(0))
g_loss = F.mse_loss(D_Y(fake_Y), fake_labels)
reconstructed_X = G_YtoX(fake_Y)
# Compute the cycle consistency loss (the reconstruction loss)
cycle_consistency_loss = torch.abs(
reconstructed_X - images_X).sum() / images_X.size(0)
# cycle_consistency_loss = F.mse_loss(reconstructed_X, images_X)
g_loss += opts.lambda_cycle * cycle_consistency_loss
g_loss.backward()
g_optimizer.step()
# Print the log info
if iteration % opts.log_step == 0:
print(
'Iteration [{:5d}/{:5d}] | d_real_loss: {:6.4f} | d_Y_loss: {:6.4f} | d_X_loss: {:6.4f} | '
'd_fake_loss: {:6.4f} | g_loss: {:6.4f}'.format(
iteration, opts.train_iters, d_real_loss.item(),
D_Y_loss.item(), D_X_loss.item(), d_fake_loss.item(),
g_loss.item()))
# Save the generated samples
if iteration % opts.sample_every == 0:
cyclegan_save_samples(iteration, fixed_Y, fixed_X, G_YtoX,
G_XtoY, opts)
# Save the model parameters
if iteration % opts.checkpoint_every == 0:
cyclegan_checkpoint(iteration, G_XtoY, G_YtoX, D_X, D_Y, opts)
except KeyboardInterrupt:
print('Exiting early from training.')
return G_XtoY, G_YtoX, D_X, D_Y
return G_XtoY, G_YtoX, D_X, D_Y
def gan_training_loop(dataloader, test_dataloader, opts):
"""Runs the training loop.
* Saves checkpoint every opts.checkpoint_every iterations
* Saves generated samples every opts.sample_every iterations
"""
# Create generators and discriminators
G, D = create_model(opts)
g_params = G.parameters() # Get generator parameters
d_params = D.parameters() # Get discriminator parameters
# Create optimizers for the generators and discriminators
g_optimizer = optim.Adam(g_params, opts.lr, [opts.beta1, opts.beta2])
d_optimizer = optim.Adam(d_params, opts.lr * 2., [opts.beta1, opts.beta2])
train_iter = iter(dataloader)
test_iter = iter(test_dataloader)
# Get some fixed data from domains X and Y for sampling. These are images that are held
# constant throughout training, that allow us to inspect the model's performance.
fixed_noise = sample_noise(100,
opts.noise_size) # 100 x noise_size x 1 x 1
iter_per_epoch = len(train_iter)
total_train_iters = opts.train_iters
try:
for iteration in range(1, opts.train_iters + 1):
# Reset data_iter for each epoch
if iteration % iter_per_epoch == 0:
train_iter = iter(dataloader)
real_images, real_labels = train_iter.next()
real_images, real_labels = to_var(real_images), to_var(
real_labels).long().squeeze()
d_optimizer.zero_grad()
# Compute the discriminator loss on real images
real_labels = label_ones(real_images.size(0))
D_real_loss = F.mse_loss(D(real_images), real_labels)
# Sample noise
noise = sample_noise(real_labels.size(0), opts.noise_size)
# Generate fake images from the noise
fake_images = G(noise)
# Compute the discriminator loss on the fake images
fake_labels = label_zeros(fake_images.size(0))
D_fake_loss = F.mse_loss(D(fake_images), fake_labels)
# Compute the total discriminator loss
D_total_loss = 0.5 * D_real_loss + 0.5 * D_fake_loss
D_total_loss.backward()
d_optimizer.step()
# TRAIN THE GENERATOR
g_optimizer.zero_grad()
# Sample noise
noise = sample_noise(real_labels.size(0), opts.noise_size)
# Generate fake images from the noise
fake_images = G(noise)
# Compute the generator loss
real_labels = label_ones(fake_images.size(0))
G_loss = F.mse_loss(D(fake_images), real_labels)
G_loss.backward()
g_optimizer.step()
# Print the log info
if iteration % opts.log_step == 0:
print(
'Iteration [{:4d}/{:4d}] | D_real_loss: {:6.4f} | D_fake_loss: {:6.4f} | G_loss: {:6.4f}'
.format(iteration, total_train_iters, D_real_loss.item(),
D_fake_loss.item(), G_loss.item()))
# Save the generated samples
if iteration % opts.sample_every == 0:
gan_save_samples(G, fixed_noise, iteration, opts)
# Save the model parameters
if iteration % opts.checkpoint_every == 0:
gan_checkpoint(iteration, G, D, opts)
except KeyboardInterrupt:
print('Exiting early from training.')
return G, D
return G, D
# anchors_path = os.path.join(os.path.dirname(FLAGS.anchors_path), "yolo-tiny_anchors.txt")
anchors_path = "C:\\Users\\psilva\\Documents\\GitHub\\train-your-own-yolo\\2_Training\\src\\keras_yolo3\\model_data\\text_files\\yolo-tiny_anchors.txt"
anchors = get_anchors(anchors_path)
input_shape = (416, 416) # Multiple of 32, height, width
epoch1, epoch2 = FLAGS.epochs, FLAGS.epochs
is_tiny_version = len(anchors) == 0 # Default setting
if FLAGS.is_tiny:
model = create_tiny_model(input_shape,
anchors,
freeze_body=2,
weights_path=weights_path,
num_classes=num_classes)
else:
model = create_model(input_shape,
anchors,
num_classes,
freeze_body=2,
weights_path=weights_path)
log_dir_time = os.path.join(log_dir, "{}".format(int(time())))
logging = TensorBoard(log_dir=log_dir_time)
checkpoint = ModelCheckpoint(os.path.join(log_dir, "checkpoint.h5"),
monitor="val_loss",
save_weights_only=True,
save_best_only=True,
period=5)
reduce_lr = ReduceLROnPlateau(monitor="val_loss",
factor=0.1,
patience=3,
verbose=1)
early_stopping = EarlyStopping(monitor="val_loss",
min_delta=0,
data_dict = {
'filtered_trainloader': filtered_trainloader,
'trainloader': trainloader,
'valloader': valloader,
'testloader': testloader,
'clean_idxs_train': clean_idxs_train,
'noisy_idxs_train': noisy_idxs_train,
'clean_labels': analysis_dict['clean_labels'],
'noisy_labels': analysis_dict['noisy_labels'],
'num_classes': num_classes
}
"""
########################### Initialize Model ##################################
"""
print('==> Building model..')
model = create_model()
ema_model = create_model(ema=True)
swa_model = create_model(ema=True)
swa_model_optim = optim_weight_swa.WeightSWA(swa_model)
if args.fastswa_frequencies is not None:
fastswa_freqs = [int(item) for item in args.fastswa_frequencies.split('-')]
print("Frequent SWAs with frequencies =", fastswa_freqs)
fastswa_nets = [create_model(ema=True) for _ in fastswa_freqs]
fastswa_optims = [
optim_weight_swa.WeightSWA(fastswa_net) for fastswa_net in fastswa_nets
]
# fastswa_logs = [context.create_train_log("fastswa_validation_freq{}".format(freq)) for freq in fastswa_freqs]
# make directories
name_exp = '_'.join([
args.arch, args.dataset, args.noise_type,
import argparse
import train_utils
parser = argparse.ArgumentParser(
description='This script helps in training the model',
)
parser.add_argument('--data_directory', dest='data_directory', action='store', default='./flowers')
parser.add_argument('--model_name', dest='model_name', action='store', default='vgg16')
parser.add_argument('--save_dir', dest='save_dir', action='store', default='checkpoint.pth')
parser.add_argument('--learning_rate', dest='learning_rate', action='store', default=0.001, type=float)
parser.add_argument('--hidden_input', dest='hidden_input', action='store', default=1024, type=int)
parser.add_argument('--epochs', dest='epochs', action='store', default=5, type=int)
parser.add_argument('--gpu', dest="mode", action="store", default="gpu")
args = parser.parse_args()
# fetch dataloaders
train_data, train_dataloader, test_dataloader, validate_dataloader = train_utils.load_data(args.data_directory)
# setup the classifier, criterion, optimizer model
model, optimizer, criterion = train_utils.create_model(
args.model_name, args.hidden_input, args.learning_rate, args.mode)
# train model
train_utils.train_model(model, optimizer, criterion, train_dataloader,
validate_dataloader, args.epochs, args.mode)
# save the model as checkpoint
train_utils.save_checkpoint(model, args, optimizer, train_data)
action="store", dest="traindata", #
help="Train images directory [default: %default]", default='src/sandbox/input/train/') #
#
parser.add_option('--output', #
action="store", dest="output", #
help="Output directory where trained model will be stored [default: %default]", default='./') #
#
parser.add_option('--trainsize', #
action="store", dest="trainsize", #
help="Train dataset size [default: %default]", default=20) #
#
options, args = parser.parse_args() #
options.width = int(options.width) #
options.height = int(options.height) #
options.epochs = int(options.epochs) #
options.trainsize = int(options.trainsize) #
TRAIN_DIR = options.traindata #
train_image_file_names = [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR)][0:options.trainsize] # Чтение названий нащих исходных данных
processed_train_images = decode_image(train_image_file_names, resize_func=getResizeFunc(options.width, options.height)) # Вызов функции преобразования наших исходных данных
labels = [1 if 'circle' in name else 0 for name in train_image_file_names] # Создание меток для обучения нашей НС.
model = create_model(options.width, options.height) # Вызов функции для создания НС
model.fit(np.array(processed_train_images), labels, epochs=options.epochs) # Вызов функции тренировки нашей НС
outputFile = options.output + 'trained_model.h5'
model.save(outputFile) # Сохранение нашей НС.
print("Trained model was saved to " + outputFile)