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
