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)