def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model_image, self.model_point = create_model(opt)
self.model_image = load_model(self.model_image, opt.load_model,
'image_model')
self.model_image = self.model_image.to(opt.device)
self.model_image.eval()
self.model_point = load_model(self.model_point, opt.load_model,
'point_model')
self.model_point = self.model_point.to(opt.device)
self.model_point.eval()
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
self.image_path = ' '
self.max_objs = 32
const = torch.Tensor([[-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0],
[0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1],
[-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0],
[0, -1]])
self.const = const.unsqueeze(0).unsqueeze(0)
self.const = self.const.to(self.opt.device)
def teacher_train(cfg, start_epoch):
torch.manual_seed(cfg.SEED)
device = torch.device('cuda' if cfg.GPU[0] >= 0 else 'cpu')
if start_epoch == 1:
train_log = open(os.path.join(cfg.LOG_DIR, "train_log.csv"), 'w')
train_log_title = "epoch,total_loss,hm_loss,wh_loss"
val_log = open(os.path.join(cfg.LOG_DIR, "val_log.csv"), 'w')
val_log_title = "epoch,precision,recall\n"
if cfg.USE_OFFSET:
train_log_title += ",offset_loss\n"
else:
train_log_title += "\n"
train_log.write(train_log_title)
train_log.flush()
val_log.write(val_log_title)
val_log.flush()
else:
train_log = open(os.path.join(cfg.LOG_DIR, "train_lo.csv"), 'a')
val_log = open(os.path.join(cfg.LOG_DIR, "val_log.csv"), 'a')
print('Creating model...')
teacher = create_model(cfg, 'res_18')
teacher = load_model(teacher, 'log/weights/model_last_res.pth')
model = create_model(cfg, 'litnet')
if start_epoch != 1:
model = load_model(
model, 'log/weights/model_epoch_{}.pth'.format(start_epoch - 1))
optimizer = torch.optim.Adam(model.parameters(), cfg.LR)
trainer = TeacherTrainer(cfg, teacher, model, optimizer)
trainer.set_device(cfg.GPU, device)
print('Setting up data...')
train_loader = DataLoader(TrainCircleDataset(cfg),
batch_size=cfg.BATCH_SIZE,
shuffle=True,
num_workers=cfg.NUM_WORKERS,
pin_memory=True,
drop_last=True)
val_loader = ValCircleDataset()
print('Starting training...')
epoch = start_epoch
for epoch in range(start_epoch, start_epoch + cfg.NUM_EPOCHS):
trainer.train(epoch, train_loader, train_log)
model_path = os.path.join(cfg.WEIGHTS_DIR,
'model_epoch_{}.pth'.format(epoch))
save_model(model_path, epoch, model, optimizer)
trainer.val(epoch, model_path, val_loader, val_log, cfg)
save_model(os.path.join(cfg.WEIGHTS_DIR, 'model_last.pth'), epoch, model,
optimizer)
def __init__(self, options):
if options.gpus[0] >= 0:
try:
self.ctx = mx.gpu()
_ = nd.zeros((1, ), ctx=self.ctx)
except mx.base.MXNetError:
print("No GPU available. Use CPU instead.")
self.ctx = mx.cpu()
else:
self.ctx = mx.cpu()
print("Creating model...")
self.model = create_model(options.arch,
options.heads,
options.head_conv,
ctx=self.ctx)
if options.load_model_path != '':
self.model = load_model(self.model,
options.load_model_path,
ctx=self.ctx)
self.mean = np.array(options.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(options.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = options.num_classes
self.scales = options.test_scales
self.opt = options
self.pause = True
def __init__(self, opt, frame_rate=30):
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv,
num_gnn_layers=opt.num_gnn_layers,
gnn_type=opt.gnn_type,
use_residual=opt.use_residual,
return_pre_gnn_layer_outputs=opt.return_pre_gnn_layer_outputs,
heads_share_params=opt.heads_share_params,
omit_gnn=opt.omit_gnn,
use_roi_align=opt.use_roi_align,
viz_attention=opt.viz_attention)
self.model = load_model(self.model, opt.load_model, distributed=True, copy_head_weights=False)
self.model = self.model.to(opt.device)
self.model.eval()
self.tracked_stracks = [] # type: list[STrack]
self.lost_stracks = [] # type: list[STrack]
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
# self.det_thresh = opt.conf_thres
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer)
self.max_time_lost = self.buffer_size
self.max_per_image = opt.K
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter()
self.viz_attention = opt.viz_attention
def __init__(self, opt, frame_rate=30):
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
self.tracked_stracks = [] # type: list[STrack]
self.lost_stracks = [] # type: list[STrack]
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.det_thresh = opt.conf_thres
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer)
self.max_time_lost = self.buffer_size
self.max_per_image = 128
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter()
def __init__(self, opt, frame_rate=30):
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
# input = torch.randn(1, 3, 640, 640, requires_grad=True)
# input=input.to(opt.device)
# out = self.model(input)
# torch.onnx.export(self.model, # model being run
# input, # model input (or a tuple for multiple inputs)
# "./test.onnx", # where to save the model (can be a file or file-like object)
# export_params=True, # store the trained parameter weights inside the model file# )
# opset_version=9
# )
self.tracked_stracks = [] # type: list[STrack]
self.lost_stracks = [] # type: list[STrack]
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.det_thresh = opt.conf_thres
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer)
self.max_time_lost = self.buffer_size
self.max_per_image = opt.K
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter()
def __init__(self, opt, frame_rate=30): # 帧率的意义
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv) # 加载模型，
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
self.tracked_stracks = [] # type: list[STrack] # 保存一系列追踪中的轨迹
self.lost_stracks = [] # type: list[STrack] # 保存已经丢失的轨迹
self.removed_stracks = [] # type: list[STrack] # 保存已经移除的轨迹
self.frame_id = 0
self.det_thresh = opt.conf_thres # 检测框阈值，这里设置为与tracking的置信度阈值相同
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer) # 还是等于输入视频的真实帧率
self.max_time_lost = self.buffer_size # 最大连续self.buffer_size次没有匹配到目标时，表示该轨迹丢失
self.max_per_image = 128
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter() # 预测，根据上一帧目标的检测位置和速度，预测当前帧目标的检测位置和速度
def prepare_data_csv():
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
arcface = load_model('resnet50', pretrained=True)
mtcnn = MTCNN(device=device)
imgdataset = ImageFolder('./data/facebank')
imgs = []
transf = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
labels = []
for img, label in imgdataset:
boxes, landmarks = mtcnn.detect_faces(img)
align = align_crop(img, landmarks, imgsize=112)
align = transf(align)
imgs.append(align)
labels.append(label)
imgs = torch.stack(imgs)
embs = arcface(imgs.to(device)).data.cpu().numpy()
idx_to_class = {}
for a in imgdataset.class_to_idx:
idx_to_class[imgdataset.class_to_idx[a]] = a
name_labels = [idx_to_class[i] for i in labels]
people = pd.DataFrame(embs)
people['id'] = name_labels
people.to_csv('./data/people.csv', index=False)
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch,
opt.heads,
opt.head_conv,
number_stacks=opt.number_stacks,
fsm=opt.fsm,
drmc=opt.drmc,
drmr=opt.drmr,
only_ls=opt.only_ls)
self.model = load_model(self.model, opt.load_model, test=True)
self.model = self.model.to(opt.device)
self.model.eval()
if opt.gene_guided_grad_cam:
self.act_maps = []
self.register_hooks()
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
# modified by condi
# self.max_per_image = 100
self.max_per_image = opt.K
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
def __init__(self, opt, frame_rate=30):
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
# convert to onnx
# input_names = ["input0"]
# output_names = ["hm", "wh", "id", "reg"]
# inputs = torch.randn(1, 3, 480, 640).to('cpu')
# torch_out = torch.onnx._export(self.model, inputs, 'pruned.onnx', export_params=True, verbose=False,
# input_names=input_names, output_names=output_names)
# print("export onnx sucess")
self.tracked_stracks = [] # type: list[STrack]
self.lost_stracks = [] # type: list[STrack]
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.det_thresh = opt.conf_thres
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer)
self.max_time_lost = self.buffer_size
self.max_per_image = opt.K
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter()
def __init__(self, opt, frame_rate=30):
self.opt = opt
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
self.tracked_stracks = [] # type: list[STrack]
self.lost_stracks = [] # type: list[STrack]
self.removed_stracks = [] # type: list[STrack]
self.frame_id = 0
self.det_thresh = opt.conf_thres
self.buffer_size = int(frame_rate / 30.0 * opt.track_buffer)
self.max_time_lost = self.buffer_size
self.max_per_image = opt.K
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.kalman_filter = KalmanFilter()
self.roi_align = RoIAlign(7, 7)
cfg = get_config()
cfg.merge_from_file(
"/home/hongwei/track-human/FairMOT/src/lib/tracker/deep_configs/yolov3.yaml"
)
cfg.merge_from_file(
"/home/hongwei/track-human/FairMOT/src/lib/tracker/deep_configs/deep_sort.yaml"
)
self.detector = build_detector(cfg, True)
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
# self.tb = SummaryWriter(
# log_dir='/home/wanghongwei/WorkSpace/source/detect/CenterNet/log/', comment='dla')
self.model = create_model(opt.arch,
opt.heads,
opt.head_conv,
vis_graph=opt.vis_graph)
try:
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.model.eval()
except Exception as e:
print(e)
print('maybe the model is None!!')
raise e
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
def main(opt):
torch.manual_seed(opt.seed)
torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test
Dataset = get_dataset(opt.dataset)
opt = opts().update_dataset_info_and_set_heads(opt, Dataset)
print(opt)
logger = Logger(opt)
os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str
opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu')
print('Creating model...')
model = create_model(opt.arch, opt.heads, opt.head_conv)
optimizer = torch.optim.Adam(model.parameters(), opt.lr)
start_epoch = 0
if opt.load_model != '':
model, optimizer, start_epoch = load_model(model, opt.load_model,
optimizer, opt.resume,
opt.lr, opt.lr_step)
Trainer = train_factory[opt.task]
trainer = Trainer(opt, model, optimizer)
trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device)
train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'),
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers,
pin_memory=True,
drop_last=True)
print('Starting training...')
for epoch in range(start_epoch + 1, opt.num_epochs + 1):
mark = epoch if opt.save_all else 'last'
log_dict_train, _ = trainer.train(epoch, train_loader)
logger.write('epoch: {} |'.format(epoch))
for k, v in log_dict_train.items():
logger.scalar_summary('train_{}'.format(k), v, epoch)
logger.write('{} {:8f} | '.format(k, v))
if epoch > 100:
save_model(
os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)),
epoch, model, optimizer)
else:
save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch,
model, optimizer)
logger.write('\n')
if epoch in opt.lr_step:
save_model(
os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)),
epoch, model, optimizer)
lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1))
print('Drop LR to', lr)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
logger.close()
def train(model,
training_parameters,
model_choice,
target,
model_name_suffix=''):
optimizer = tf.keras.optimizers.Adam(1e-2)
log_joint_pdf = get_log_joint_pdf(training_parameters['name'])
# Early stopping
best_loss = 1e20
last_improvement = 0
max_consecutive_no_improvement = 15000
min_epoch_checkpoint = 1
checkpoint_tol = 0.02
saved_checkpoint = False
# Monitor training loss for visualisation
loss_monitor = []
for epoch in range(1, training_parameters['epochs']):
loss = compute_apply_gradients(model, optimizer, log_joint_pdf)
if loss < best_loss:
if ((best_loss - loss) / np.abs(best_loss) >
checkpoint_tol) & (epoch > min_epoch_checkpoint):
print(
f" - CHECKPOINT for epoch {epoch + 1}, current best loss {loss}"
)
save_model(model,
model_choice,
target,
model_name_suffix=model_name_suffix)
best_loss = loss
last_improvement = 0
saved_checkpoint = True
else:
last_improvement += 1
if last_improvement >= max_consecutive_no_improvement:
print(f" - STOPPED after {epoch} epochs")
break
if epoch % 100 == 0:
print(f"Epoch {epoch}, loss: {loss}")
loss_monitor.append(loss)
plt.figure()
plt.plot(loss_monitor, color='slategrey')
plt.xlabel('Epochs (x100)')
plt.ylabel('-ELBO(q)')
if saved_checkpoint:
model = load_model(model_choice,
training_parameters,
model_name_suffix='')
return model
def __init__(self, opt):
self.model = create_model(opt.arch,
opt.heads,
opt.head_conv,
opt.num_layers,
training=False,
channel_last=opt.channel_last)
if opt.checkpoint != '':
extension = os.path.splitext(opt.checkpoint)[1]
assert (
extension == '.h5' or extension == ".protobuf"
), "incorrect file extension, should be either .h5 or .protobuf"
load_model(self.model, opt.checkpoint, clear=True)
self.mean = opt.mean
self.std = opt.std
self.max_per_image = 128
self.opt = opt
self.pause = True
def __init__(self, model='resnet50', device=None):
if device is None:
self.device = torch.device(
'cuda:0' if torch.cuda.is_available() else 'cpu')
else:
self.device = device
self.mtcnn = MTCNN(device=self.device)
self.net = load_model(model, device=self.device, pretrained=True)
# self.vec, self.name = load_vec(pd.read_csv(facevec))
self.vec, self.name = load_data_from_database()
def __init__(self, opt):
torch.manual_seed(opt.seed)
torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test
Dataset = get_dataset(opt.dataset, opt.task)
opt = opts().update_dataset_info_and_set_heads(opt, Dataset)
self.opt = opt
print(opt)
self.logger = Logger(opt)
os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str
opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu')
print('Creating model...')
model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = model
optimizer = torch.optim.Adam(model.parameters(), opt.lr)
self.optimizer = optimizer
start_epoch = 0
if opt.load_model != '':
model, optimizer, start_epoch = load_model(model, opt.load_model,
optimizer, opt.resume,
opt.lr, opt.lr_step)
Trainer = train_factory[opt.task]
trainer = Trainer(opt, model, optimizer)
trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device)
self.trainer = trainer
print('Setting up data...')
val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'),
batch_size=1,
shuffle=False,
num_workers=1,
pin_memory=True)
self.val_loader = val_loader
if opt.test:
_, preds = trainer.val(0, val_loader)
val_loader.dataset.run_eval(preds, opt.save_dir)
return
train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'),
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers,
pin_memory=True,
drop_last=True)
self.train_loader = train_loader
self.best = 1e10
def __init__(self,
model_path,
conf_thres=0.4,
model_name='dla_34',
device='cpu'):
heads = {'hm': 1, 'wh': 4, 'id': 128, 'reg': 2}
head_conv = 256
self.device = device
self.conf_thres = conf_thres
self.model = create_model(model_name, heads, head_conv)
self.model = load_model(self.model, model_path)
self.model = self.model.to(device)
self.model.eval()
def train(args, device_id):
""" Starts training pipeline given CLI args """
device = "cpu" if args.visible_gpus == '-1' else "cuda"
logger.info('Device ID %d' % device_id)
logger.info('Device %s' % device)
seed(args.seed, device_id)
def train_iter_fct():
return data.load(args, 'train', device)
if args.train_from != '':
logger.info("Training from checkpoint %s", args.train_from)
model, optim = load_model(args,
device,
load_bert=True,
checkpoint=args.train_from)
else:
logger.info("Training without checkpoint")
model, optim = load_model(args, device, load_bert=True)
logger.info(model)
trainer = build_trainer(args, device_id, model, optim)
trainer.train(train_iter_fct, args.train_steps)
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.num_classes)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.num_classes = opt.num_classes
self.opt = opt
self.pause = True
def __init__(self, cfg):
print('Creating model...')
self.model = create_model(cfg.MODEL.NAME, cfg.MODEL.HEAD_CONV, cfg)
self.model = load_model(self.model, cfg.TEST.MODEL_PATH)
self.model = self.model.to(torch.device('cuda'))
self.model.eval()
self.mean = np.array(cfg.DATASET.MEAN, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(cfg.DATASET.STD, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = cfg.MODEL.NUM_CLASSES
self.scales = cfg.TEST.TEST_SCALES
self.cfg = cfg
self.pause = True
def demo(opt):
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
opt.device = torch.device('cuda')
print('Loading images...')
if os.path.isdir(opt.demo):
image_names = []
ls = os.listdir(opt.demo)
for file_name in sorted(ls):
ext = file_name[file_name.rfind('.') + 1:].lower()
if ext in image_ext:
image_names.append(os.path.join(opt.demo, file_name))
else:
image_names = [opt.demo]
print('Creating model...')
model = create_model(opt.arch, opt.heads, opt.head_conv)
model = load_model(model, opt.load_model)
model = model.to(opt.device)
for (image_name) in image_names:
image = cv2.imread(image_name)
original_images = pre_process(image)
original_images = original_images.to(opt.device)
images = torch.tensor(original_images)
images.requires_grad = True
for i in range(20):
hm = model(images)[-1]['hm'].sigmoid_()
scores = _topk(hm, K=1)
loss = torch.sum(scores)
if loss > 0:
print(loss)
model.zero_grad()
loss.backward()
grad = images.grad.data.sign()
images = images - 0.4 * grad
images = torch.clamp(images, -1, 1)
else:
break
perturb = (images - original_images).squeeze(0).numpy()
perturb = perturb.transpose(1, 2, 0)
perturb = perturb * np.array(opt.std, dtype=np.float32).reshape(
1, 1, 3).astype(np.float32) * 255
perturb = (perturb.astype(np.int16) + 128).clip(0, 255)
perturb = cv2.resize(perturb, (image.shape[0:2]))
perturb = perturb - 128
adv_image = (image + perturb).clip(0, 255)
cv2.imwrite('results/' + image_name, adv_image)
def __init__(self, model_path, cfg):
super(Detector, self).__init__()
self.cfg = cfg
print('Creating model...')
self.model = create_model(self.cfg, 'res_18')
self.model = load_model(self.model, model_path)
self.model = self.model.to(self.cfg.DEVICE)
self.model.eval()
self.mean = np.array(self.cfg.DATA_MEAN,
dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(self.cfg.DATA_STD,
dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = cfg.K
self.scales = self.cfg.TEST_SCALES
self.pause = True
def __init__(self, sess, model_saved_path, labels_path, fix_ratio, **_):
with open(labels_path) as f:
self.labels = f.read().splitlines()
self.image_shape = [600, 600, 3] # TODO
self.opt = opt = opts().parse('ctdet --dataset bdd --keep_res'.split()) # TODO: others than bdd
Dataset = get_dataset(opt.dataset, opt.task)
opts.update_dataset_info_and_set_heads(None, opt, Dataset)
model = create_model(opt.arch, opt.heads, opt.head_conv)
model = load_model(model, model_saved_path)
# TODO: loss
# TODO: model_with_loss
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model = model.to(self.device) # TODO: model_with_loss
self.model.eval() # TODO: model_with_loss
self.fix_ratio = fix_ratio
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model)
self.model = self.model.to(opt.device)
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda') # can be multi gpu
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, opt.load_model) # load pretrain
self.model = self.model.to(opt.device)
self.model.eval() # set BN, Dropout constant
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = opt.K # 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
def __init__(self, opt):
if opt.gpus[0] >= 0:
opt.device = torch.device('cuda')
else:
opt.device = torch.device('cpu')
print('Creating model...')
self.model = create_model(opt.arch, opt.heads, opt.head_conv)
self.model = load_model(self.model, "/nfs4/ajaym/Downloads/cendeep_sort_pytorch-master/centernet/models/ctdet_coco_dla_2x.pth")
self.model = self.model.to(opt.device)
self.model.eval()
self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
self.pause = True
def __init__(self):
logging.info('Creating model...')
self.model = create_model(arch, heads, head_conv)
self.model = load_model(self.model, model_path)
self.model = self.model.to(device)
self.model.eval()
logging.info('model loaded.')
self.mean = np.array(mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(std, dtype=np.float32).reshape(1, 1, 3)
self.max_per_image = 100
self.num_classes = num_classes
self.scales = test_scales
self.pad = pad
self.mean = mean
self.std = std
self.down_ratio = down_ratio
self.input_shape = input_shape
self.K = K_outputs
self.pause = True
def __init__(self, num_layers, opt):
super().__init__()
heads = {'hm': 80, 'wh': 4}
model = get_hardnet(num_layers=num_layers,
heads=opt.heads,
head_conv=opt.head_conv,
trt=True)
if opt.load_model:
model = load_model(model, opt.load_model)
model = fuse_bn_recursively(model)
model.v2_transform()
self.model = model
mean = np.array(opt.mean, dtype=np.float32).reshape(1, 3, 1, 1)
std = np.array(opt.std, dtype=np.float32).reshape(1, 3, 1, 1)
self.mean = nn.Parameter(torch.from_numpy(mean))
self.std = nn.Parameter(torch.from_numpy(std))
self.max_per_image = 100
self.num_classes = opt.num_classes
self.scales = opt.test_scales
self.opt = opt
def main(opt):
torch.manual_seed(opt.seed)
torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test
Dataset = get_dataset(opt.dataset, opt.task)
opt = opts().update_dataset_info_and_set_heads(opt, Dataset)
os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str
opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu')
print('Creating model...')
model = create_model(opt.arch, opt.heads, opt.head_conv)
optimizer = torch.optim.Adam(model.parameters(), opt.lr)
model, optimizer, start_epoch = load_model(model, opt.load_model,
optimizer, opt.resume, opt.lr,
opt.lr_step)
print(opt)
Trainer = train_factory[opt.task]
trainer = Trainer(opt, model, optimizer)
trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device)
print('Setting up data...')
val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'),
batch_size=1,
shuffle=False,
num_workers=1,
pin_memory=True)
train_loader = torch.utils.data.DataLoader(Dataset(opt, 'train'),
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers,
pin_memory=True,
drop_last=True)
print('Starting training...')
best = 1e10
train_stat = trainer.wta_stat(start_epoch, train_loader)
val_stat = trainer.wta_stat(start_epoch, val_loader)
def main():
# parse options
op = Options()
opt = op.parse()
# initialize train or test working dir
trainer_dir = "trainer_" + opt.name
opt.model_dir = os.path.join(opt.dir, trainer_dir, "Train")
opt.data_dir = os.path.join(opt.dir, trainer_dir, "Data")
opt.test_dir = os.path.join(opt.dir, trainer_dir, "Test")
if not os.path.exists(opt.data_dir):
os.makedirs(opt.data_dir)
if opt.mode == "Train":
if not os.path.exists(opt.model_dir):
os.makedirs(opt.model_dir)
log_dir = opt.model_dir
log_path = log_dir + "/train.log"
if opt.mode == "Test":
if not os.path.exists(opt.test_dir):
os.makedirs(opt.test_dir)
log_dir = opt.test_dir
log_path = log_dir + "/test.log"
# save options to disk
util.opt2file(opt, log_dir+"/opt.txt")
# log setting
log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(log_format)
fh = logging.FileHandler(log_path, 'a')
fh.setFormatter(formatter)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logging.getLogger().addHandler(fh)
logging.getLogger().addHandler(ch)
log_level = logging.INFO
logging.getLogger().setLevel(log_level)
# load train or test data
data_loader = MultiLabelDataLoader(opt)
if opt.mode == "Train":
train_set = data_loader.GetTrainSet()
val_set = data_loader.GetValSet()
elif opt.mode == "Test":
test_set = data_loader.GetTestSet()
num_classes = data_loader.GetNumClasses()
rid2name = data_loader.GetRID2Name()
id2rid = data_loader.GetID2RID()
opt.class_num = len(num_classes)
# load model
model = load_model(opt, num_classes)
# define loss function
criterion = nn.CrossEntropyLoss(weight=opt.loss_weight)
# use cuda
if opt.cuda:
model = model.cuda(opt.devices[0])
criterion = criterion.cuda(opt.devices[0])
cudnn.benchmark = True
# Train model
if opt.mode == "Train":
train(model, criterion, train_set, val_set, opt, (rid2name, id2rid))
# Test model
elif opt.mode == "Test":
test(model, criterion, test_set, opt)
def main():
# parse options
op = Options()
opt = op.parse()
# special setting
opt.shuffle = False
opt.batch_size = 1
opt.load_thread = 1
# initialize train or test working dir
test_dir = os.path.join(opt.classify_dir , opt.name)
opt.model_dir = opt.dir + "/trainer_" + opt.name + "/Train/"
if not os.path.exists(test_dir):
os.mkdir(test_dir)
# save options to disk
opt2file(opt, os.path.join(test_dir, "opt.txt"))
# log setting
log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(log_format)
fh = logging.FileHandler(test_dir + "/deploy.log", 'a')
fh.setFormatter(formatter)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logging.getLogger().addHandler(fh)
logging.getLogger().addHandler(ch)
logging.getLogger().setLevel(logging.INFO)
# load label
if opt.label_file == "":
opt.label_file = opt.dir + "/label.txt"
rid2name, id2rid, rid2id = load_label(opt.label_file)
num_classes = [len(rid2name[index])-2 for index in range(len(rid2name))]
# load transformer
transformer = get_transformer(opt)
# load model
model = load_model(opt, num_classes)
model.eval()
# use cuda
if opt.cuda:
model = model.cuda(opt.devices[0])
cudnn.benchmark = True
l = open(test_dir + "/classify_res_data.txt", 'w')
with open(opt.classify_dir + "/data.txt") as data:
for num, line in enumerate(data):
logging.info(str(num+1))
line = json.loads(line)
input_tensor = load_image(line["image_file"], line["box"], opt, transformer)
input_tensor = input_tensor.unsqueeze(0)
if opt.cuda:
input_tensor = input_tensor.cuda(opt.devices[0])
outputs = model(Variable(input_tensor, volatile=True))
if not isinstance(outputs, list):
outputs = [outputs]
line["classify_res"] = list()
for index, out in enumerate(outputs):
out = out.cpu()
#print "out:", out
softmax = F.softmax(out, dim=1).data.squeeze()
#print "softmax:", softmax
probs, ids = softmax.sort(0, True)
classify_res = {}
for i in range(len(probs)):
classify_res[rid2name[index][id2rid[index][ids[i]]]] = probs[i]
classify_res["max_score"] = probs[0]
classify_res["best_label"] = rid2name[index][id2rid[index][ids[0]]]
line["classify_res"].append(classify_res)
l.write(json.dumps(line, separators=(',', ':'))+'\n')
l.close()
logging.info("classification done")
