def main(args): ############################### # TRAIN PREP ############################### print("Loading data") train_loader, valid_loader, data_var, input_size = \ data.get_data(args.data_folder,args.batch_size) args.input_size = input_size args.downsample = args.input_size[-1] // args.enc_height args.data_variance = data_var print(f"Training set size {len(train_loader.dataset)}") print(f"Validation set size {len(valid_loader.dataset)}") print("Loading model") if args.model == 'diffvqvae': model = DiffVQVAE(args).to(device) elif args.model == 'vqvae': model = VQVAE(args).to(device) print( f'The model has {utils.count_parameters(model):,} trainable parameters' ) optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, amsgrad=False) print(f"Start training for {args.num_epochs} epochs") num_batches = math.ceil( len(train_loader.dataset) / train_loader.batch_size) pbar = Progress(num_batches, bar_length=10, custom_increment=True) # Needed for bpd args.KL = args.enc_height * args.enc_height * args.num_codebooks * \ np.log(args.num_embeddings) args.num_pixels = np.prod(args.input_size) ############################### # MAIN TRAIN LOOP ############################### best_valid_loss = float('inf') train_bpd = [] train_recon_error = [] train_perplexity = [] args.global_it = 0 for epoch in range(args.num_epochs): pbar.epoch_start() train_epoch(args, vq_vae_loss, pbar, train_loader, model, optimizer, train_bpd, train_recon_error, train_perplexity) # loss, _ = test(valid_loader, model, args) # pbar.print_eval(loss) valid_loss = evaluate(args, vq_vae_loss, pbar, valid_loader, model) if valid_loss < best_valid_loss: best_valid_loss = valid_loss best_valid_epoch = epoch torch.save(model.state_dict(), args.save_path) pbar.print_end_epoch() print("Plotting training results") utils.plot_results(train_recon_error, train_perplexity, "results/train.png") print("Evaluate and plot validation set") generate_samples(model, valid_loader)
self.autoencoder.save(self.autoencoder_model_pkl) self.encoder.save(self.encoder_model_pkl) self.decoder.save(self.decoder_model_pkl) else: # Save models self.autoencoder = load_model(self.autoencoder_model_pkl) self.encoder = load_model(self.encoder_model_pkl) self.decoder = load_model(self.decoder_model_pkl) def predict(self, test_profile_images): png_profile_images = self.process_images(test_profile_images) encoded_imgs = self.encoder.predict(png_profile_images) decoded_imgs = self.decoder.predict(encoded_imgs) return test_profile_images, decoded_imgs if __name__ == "__main__": profile_gray_objs, midcurve_gray_objs = get_training_data() test_gray_images = random.sample(profile_gray_objs, 5) profile_gray_objs = np.asarray(profile_gray_objs) / 255. midcurve_gray_objs = np.asarray(midcurve_gray_objs) / 255. test_gray_images = np.asarray(test_gray_images) / 255. endec = dense_encoderdecoder() endec.train(profile_gray_objs, midcurve_gray_objs) original_profile_imgs, predicted_midcurve_imgs = endec.predict( test_gray_images) plot_results(original_profile_imgs, predicted_midcurve_imgs)
for i, (image, label) in enumerate(zip(X_train, y_train)): loss, acc = train(image, label, model, alpha) loss_train += loss acc_train += acc for i, (image, label) in enumerate(zip(X_test, y_test)): _, loss, acc = forward(image, label, model) loss_test += loss acc_test += acc loss_train_seq.append(loss_train / train_examples) loss_test_seq.append(loss_test / test_examples) acc_train_seq.append(acc_train / train_examples) acc_test_seq.append(acc_test / test_examples) print('Test Loss: {}\nTest Accuracy: {} %'.format( loss_test_seq[-1], acc_test_seq[-1] * 100)) print('Train Loss: {}\nTrain Accuracy: {} %\n\n'.format( loss_train_seq[-1], acc_train_seq[-1] * 100)) file.write('Test Loss: {}\nTest Accuracy: {} %'.format( loss_test_seq[-1], acc_test_seq[-1] * 100)) file.write('Train Loss: {}\nTrain Accuracy: {} %\n\n'.format( loss_train_seq[-1], acc_train_seq[-1] * 100)) plot_results(loss_train_seq, loss_test_seq, acc_train_seq, acc_test_seq) file.close() print('Done!')
profile_pngs = [] test_profile_pngs = [] print(profile_pngs_objs.shape) print(profile_pngs_objs[0].shape) print(test_gray_images.shape) print(test_gray_images[0].shape) print(coords.shape) for i in range(len(profile_pngs_objs)): profile_pngs.append( np.concatenate((coords, profile_pngs_objs[i]), axis=-1)) for i in range(len(test_gray_images)): test_profile_pngs.append( np.concatenate((coords, test_gray_images[i]), axis=-1)) profile_pngs = np.asarray(profile_pngs) test_profile_pngs = np.asarray(test_profile_pngs) endec = cnn_encoderdecoder(input_shape=(128, 128, 3)) endec.train(profile_pngs, midcurve_pngs_objs) #print(test_profile_pngs.shape) original_profile_imgs, predicted_midcurve_imgs = endec.predict( test_profile_pngs, expand_dims=False) plot_results(original_profile_imgs[:, :, :, 2], predicted_midcurve_imgs, size=(128, 128)) #original_imgs,decoded_imgs = build_cnn_encoderdecoder_model(profile_pngs, midcurve_pngs_objs) #plot_results(original_imgs,decoded_imgs)
def create_dataset(clothing, categories, dataset_type): images_path = Path(f"clothing/images/{dataset_type}") images_path.mkdir(parents=True, exist_ok=True) labels_path = Path(f"clothing/labels/{dataset_type}") labels_path.mkdir(parents=True, exist_ok=True) for img_id, row in enumerate(tqdm(clothing)): image_name = f"{img_id}.jpeg" img = urllib.request.urlopen(row["content"]) img = Image.open(img) img = img.convert("RGB") img.save(str(images_path / image_name), "JPEG") label_name = f"{img_id}.txt" with (labels_path / label_name).open(mode="w") as label_file: for a in row['annotation']: for label in a['label']: category_idx = categories.index(label) points = a['points'] p1, p2 = points x1, y1 = p1['x'], p1['y'] x2, y2 = p2['x'], p2['y'] bbox_width = x2 - x1 bbox_height = y2 - y1 label_file.write( f"{category_idx} {x1 + bbox_width / 2} {y1 + bbox_height / 2} {bbox_width} {bbox_height}\n" ) create_dataset(train_clothing, categories, 'train') create_dataset(val_clothing, categories, 'val') from utils.utils import plot_results plot_results();
s = [ .2, .2, .2, .2, .2, .2, .2, .0, .02, .2, .2, .2, .2, .2, .2, .2, .2, .2 ] # sigmas for i, k in enumerate(hyp.keys()): x = (np.random.randn(1) * s[i] + 1)**2.0 # plt.hist(x.ravel(), 300) hyp[k] *= float(x) # vary by sigmas # Clip to limits keys = [ 'lr0', 'iou_t', 'momentum', 'weight_decay', 'hsv_s', 'hsv_v', 'translate', 'scale', 'fl_gamma' ] limits = [(1e-5, 1e-2), (0.00, 0.70), (0.60, 0.98), (0, 0.001), (0, .9), (0, .9), (0, .9), (0, .9), (0, 3)] for k, v in zip(keys, limits): hyp[k] = np.clip(hyp[k], v[0], v[1]) # Train mutation prebias() results = train() # Write mutation results print_mutation(hyp, results, opt.bucket) # Plot results # plot_evolution_results(hyp) from utils import utils utils.plot_results()
from utils import utils import sys utils.plot_results(sys.argv[1])
yolo_cfg = "cfg/yolov3-3cls.cfg" data_name = "full dataset.data" data_cfg = "data/" + data_name best_weights = "weights/best.pt" paths = glob.glob("/home/carbor/data/raw test videos/*.*") img_size = 416 resume = True # used for transfer learning epochs = 500 batch_size = 1 training = False if training: train( yolo_cfg, data_cfg, img_size=img_size, resume=resume, epochs=epochs, batch_size=batch_size, multi_scale=True, transfer=False ) plot_results() os.rename("results.txt", "results_{}.txt".format(data_name)) for path in paths: test_video(path, yolo_cfg, data_cfg, best_weights, data_name, img_size)
# ------------------------------------------------------------------------------ from __future__ import absolute_import from __future__ import division from __future__ import print_function import torch import numpy as np import imageio from configs.config2d import config from networks.convcrf2d import ConvCRF2d from utils.utils import augment_label from utils.utils import plot_results from utils.utils import process_img_unary image_file = 'data/2007_000346_0img.png' label_file = 'data/2007_000346_5labels.png' image_show = imageio.imread(image_file) label_show = imageio.imread(label_file) model = ConvCRF2d(config, kernel_size=7).to(config.device) unary_show = augment_label(label_show, num_classes=config.num_classes, scale=8, keep_prop=0.8) image, unary = process_img_unary(image_show, unary_show) image = torch.from_numpy(image).float().to(config.device) unary = torch.from_numpy(unary).float().to(config.device) output = model(image, unary) output_show = output.data.cpu().numpy() plot_results(image_show, unary_show, output_show, label_show)
plt.xticks(pruning_percent) plt.yticks(np.arange(0, 1.05, 0.05)) plt.show() def neuron_pruning(model, pruning_percentage, test_dl): model1 = copy.deepcopy(model) length = len(list(model1.parameters())) for i, param in enumerate(model1.parameters()): if len(param.size())!=1 and i<length-2: weight = param.detach().cpu().numpy() norm = np.linalg.norm(weight, axis=0) weight[:, np.argwhere(norm<np.percentile(norm, pruning_percentage))] = 0 weight = torch.from_numpy(weight).to(device) param.data = weight return test(model1, test_dl) accuracy_neuron_pruning = [] for percent in pruning_percent: accuracy_neuron_pruning.append(neuron_pruning(model, percent, test_dl)) """detection""" from utils import utils; utils.plot_results() !python3 detect.py --cfg yolov3.cfg --source /content/yolov3/data/samples/285604.jpg import matplotlib.pyplot as plt import matplotlib.image as mpimg img=mpimg.imread('/content/yolov3/output/285604.jpg') imgplot = plt.imshow(img) plt.show()
def main(): """ Train and test :param opt: args :param writer: tensorboard :return: """ global opt opt = parse() arc = opt.arc cfg = opt.cfg teacher_cfg = opt.teacher_cfg img_size = opt.img_size epochs = opt.epochs batch_size = opt.batch_size accumulate = opt.accumulate # effective bs = batch_size * accumulate = 16 * 4 = 64 weights = opt.weights teacher_weights = opt.teacher_weights multi_scale = opt.multi_scale sparsity_training = opt.st opt.weights = last if opt.resume else opt.weights # Initial logging logging.basicConfig( format="%(message)s", level=logging.INFO if opt.local_rank in [-1, 0] else logging.WARN) # Train logger.info(opt) if opt.local_rank in [-1, 0]: logger.info('Start Tensorboard with "tensorboard --logdir=runs", view at http://localhost:6006/') writer = SummaryWriter() # Hyperparameters with open(opt.hyp) as f_hyp: hyp = yaml.safe_load(f_hyp) # data dict with open(opt.data) as f_data: data = yaml.safe_load(f_data) # Distributed training initialize device = select_device(opt.device) if opt.local_rank != -1: dist.init_process_group(init_method="env://", backend='nccl') torch.cuda.set_device(opt.local_rank) device = torch.device(f"cuda:{opt.local_rank}") # world_size = torch.distributed.get_world_size() init_seeds() cuda = device.type != 'cpu' torch.backends.cudnn.benchmark = True if multi_scale: img_size_min = round(img_size / 32 / 1.5) + 1 img_size_max = round(img_size / 32 * 1.5) - 1 img_size = img_size_max * 32 # initiate with maximum multi_scale size logger.info(f'Using multi-scale {img_size_min * 32} - {img_size}') train_path = data['train'] num_classes = int(data['num_classes']) # number of classes # Load dataset dataset = LoadImagesAndLabels(train_path, img_size, batch_size, augment=True, hyp=hyp, rect=opt.rect) train_sampler = torch.utils.data.distributed.DistributedSampler(dataset) if opt.local_rank != -1 else None num_worker = os.cpu_count() // torch.cuda.device_count() dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, num_workers=min([num_worker, batch_size, 8]), shuffle=not (opt.rect or train_sampler), sampler=train_sampler, pin_memory=True, collate_fn=dataset.collate_fn) # Load model model = Model(cfg, img_size, arc=arc).to(device) # Load teacher model if teacher_cfg: teacher_model = Model(teacher_cfg, img_size, arc).to(device) # optimizer parameter groups param_group0, param_group1 = [], [] for key, value in model.named_parameters(): if 'Conv2d.weight' in key: param_group1.append(value) else: param_group0.append(value) if opt.adam: optimizer = optim.Adam(param_group0, lr=hyp['lr0']) else: optimizer = optim.SGD(param_group0, lr=hyp['lr0'], momentum=hyp['momentum'], nesterov=True) # add param_group1 with weight_decay optimizer.add_param_group({'params': param_group1, 'weight_decay': hyp['weight_decay']}) logger.info(f'Optimizer groups: {len(param_group1)} conv.weight, {len(param_group0)} other') del param_group0, param_group1 start_epoch = 0 best_fitness = 0. if weights.endswith('.pt'): checkpoint = torch.load(weights, map_location=device) state_dict = intersect_dicts(checkpoint['model'], model.state_dict()) model.load_state_dict(state_dict, strict=False) print('loaded weights from', weights, '\n') # load optimizer if checkpoint['optimizer'] is not None: optimizer.load_state_dict(checkpoint['optimizer']) best_fitness = checkpoint['best_fitness'] # load results if checkpoint.get('training_results') is not None: with open(results_file, 'w') as file: file.write(checkpoint['training_results']) # resume if opt.resume: start_epoch = checkpoint['epoch'] + 1 del checkpoint elif len(weights) > 0: # weights are 'yolov4.weights', 'darknet53.conv.74' etc. load_darknet_weights(model, weights) logger.info(f'loaded weights from {weights}\n') # Load teacher weights if teacher_cfg: if teacher_weights.endswith('.pt'): teacher_model.load_state_dict(torch.load(teacher_weights, map_location=device)['model']) elif teacher_weights.endswith('.weights'): load_darknet_weights(teacher_model, teacher_weights) else: raise Exception('pls provide proper teacher weights for knowledge distillation') if not mixed_precision: teacher_model.eval() logger.info('<......................using knowledge distillation....................>') logger.info(f'teacher model: {teacher_weights}\n') # Sparsity training if opt.prune == 0: _, _, prune_index = parse_module_index(model.module_dicts) if sparsity_training: logger.info('normal sparse training') if mixed_precision: if teacher_cfg: [model, teacher_model], optimizer = amp.initialize([model, teacher_model], optimizer, opt_level='O1', verbosity=1) else: model, optimizer = amp.initialize(model, optimizer, opt_level='O1', verbosity=1) # SyncBatchNorm and distributed training if cuda and opt.local_rank != -1: model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device) model = model.to(device) model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[opt.local_rank]) model.module_list = model.module.module_list model.yolo_layers = model.module.yolo_layers for index in prune_index: bn_weights = gather_bn_weights(model.module_list, [index]) if opt.local_rank == 0: writer.add_histogram('before_train_per_layer_bn_weights/hist', bn_weights.numpy(), index, bins='doane') # Start training model.num_classes = num_classes model.arc = opt.arc model.hyp = hyp num_batch_size = len(dataloader) # 'P', 'R', 'mAP', 'F1', 'val GIoU', 'val Objectness', 'val Classification' results = (0, 0, 0, 0, 0, 0, 0) start_train_time = time.time() logger.info('Image sizes %d \n Starting training for %d epochs...', img_size, epochs) for epoch in range(start_epoch, epochs): # epoch ------------------------------------------------------------------ model.train() mean_losses = torch.zeros(4).to(device) mean_soft_target = torch.zeros(1).to(device) pbar = enumerate(dataloader) logger.info(('\n %10s %10s %10s %10s %10s %10s %10s %10s'), 'Epoch', 'gpu_mem', 'box', 'obj', 'cls', 'total', 'targets', 'img_size') if opt.local_rank in [-1, 0]: pbar = tqdm(pbar, total=num_batch_size) optimizer.zero_grad() for i, (imgs, targets, _, _) in pbar: # batch ------------------------------------------------------------- num_integrated_batches = i + num_batch_size * epoch # Adjust the learning rate learning_rate = adjust_learning_rate(optimizer, num_integrated_batches, num_batch_size, hyp, epoch, epochs) if i == 0 and opt.local_rank in [-1, 0]: logger.info(f'learning rate: {learning_rate}') imgs = imgs.to(device) / 255.0 targets = targets.to(device) # Multi-Scale training if multi_scale: if num_integrated_batches / accumulate % 10 == 0: img_size = random.randrange(img_size_min, img_size_max + 1) * 32 scale_factor = img_size / max(imgs.shape[2:]) if scale_factor != 1: new_shape = [math.ceil(x * scale_factor / 32.) * 32 for x in imgs.shape[2:]] imgs = F.interpolate(imgs, size=new_shape, mode='bilinear', align_corners=False) pred = model(imgs) # Compute loss loss, loss_items = compute_loss(pred, targets, model) # knowledge distillation soft_target = 0 if teacher_cfg: if mixed_precision: with torch.no_grad(): output_teacher = teacher_model(imgs) else: _, output_teacher = teacher_model(imgs) soft_target = distillation_loss(pred, output_teacher, model.num_classes, imgs.size(0)) loss += soft_target # Scale loss by nominal batch_size of 64 loss *= batch_size / 64 # Compute gradient if mixed_precision: with amp.scale_loss(loss, optimizer) as scaled_loss: scaled_loss.backward() else: loss.backward() # Sparse the BN layer that needs pruning if sparsity_training: # bn_l1_regularization(model.module_list, opt.penalty_factor, cba_index, epoch, epochs) bn_l1_regularization(model.module_list, opt.penalty_factor, prune_index, epoch, epochs) # Accumulate gradient for x batches before optimizing if num_integrated_batches % accumulate == 0: optimizer.step() optimizer.zero_grad() if opt.local_rank in [-1, 0]: mean_losses = (mean_losses * i + loss_items) / (i + 1) mean_soft_target = (mean_soft_target * i + soft_target) / (i + 1) memory = torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0 # (GB) description = ('%10s' * 2 + '%10.3g' * 6) % ( '%g/%g' % (epoch, epochs - 1), '%.3gG' % memory, *mean_losses, mean_soft_target, img_size) pbar.set_description(description) # end batch ------------------------------------------------------------------------------------------------ # Update scheduler # scheduler.step() if opt.local_rank in [-1, 0]: final_epoch = epoch + 1 == epochs # Calculate mAP if not (opt.notest or opt.nosave) or final_epoch: with torch.no_grad(): results, _ = test(cfg, data, batch_size=batch_size, img_size=opt.img_size, model=model, conf_thres=0.001 if final_epoch and epoch > 0 else 0.1, # 0.1 for speed save_json=final_epoch and epoch > 0) # Write epoch results with open(results_file, 'a') as file: # P, R, mAP, F1, test_losses=(GIoU, obj, cls) file.write(description + '%10.3g' * 7 % results + '\n') # Write Tensorboard results if writer: outputs = list(mean_losses) + list(results) titles = ['GIoU', 'Objectness', 'Classification', 'Train loss', 'Precision', 'Recall', 'mAP', 'F1', 'val GIoU', 'val Objectness', 'val Classification'] for output, title in zip(outputs, titles): writer.add_scalar(title, output, epoch) bn_weights = gather_bn_weights(model.module_list, prune_index) writer.add_histogram('bn_weights/hist', bn_weights.numpy(), epoch, bins='doane') # Update best mAP fitness = results[2] if fitness > best_fitness: best_fitness = fitness # Save training results save = (not opt.nosave) or (final_epoch and not opt.evolve) if save and opt.local_rank == 0: with open(results_file, 'r') as file: # Create checkpoint checkpoint = {'epoch': epoch, 'best_fitness': best_fitness, 'training_results': file.read(), 'model': model.module.state_dict() if isinstance( model, nn.parallel.DistributedDataParallel) else model.state_dict(), 'optimizer': None if final_epoch else optimizer.state_dict()} # Save last checkpoint torch.save(checkpoint, last) # Save best checkpoint if best_fitness == fitness: torch.save(checkpoint, best) # Delete checkpoint del checkpoint # end epoch ----------------------------------------------------------------------------------------------- # end training if opt.local_rank in [-1, 0]: if len(opt.name): os.rename('results.txt', 'results_%s.txt' % opt.name) plot_results() # save as results.png print(f'{epoch - start_epoch + 1} epochs completed in {(time.time() - start_train_time) / 3600:.3f} hours.\n') if torch.cuda.device_count() > 1: dist.destroy_process_group() torch.cuda.empty_cache() return results