def predict(one_case_path, modality):
data_source = ds.Dataset(one_case_path, modality)
params = param.dict_supper_parameters
list_label_volume_data = []
for roi_name in params.keys():
print('Predicting %s' % (roi_name))
result_label_volume_data = predictor.predict(roi_name, data_source)
list_label_volume_data.append([roi_name, result_label_volume_data])
list_dicom_dataset = data_source.get_dicom_dataset_list()
roi_list = dcmio.get_roi_list(list_dicom_dataset, list_label_volume_data)
result_roi_list = []
roi_nums = len(roi_list)
for i in range(roi_nums):
roi = roi_list[i]
roi_name = roi[0]
contour_list = roi[5]
result_contour_list = []
contour_nums = len(contour_list)
for j in range(contour_nums):
contour = contour_list[j]
point_list = contour[1]
result_point_list = []
point_nums = len(point_list)
# if point_nums < 3:
# continue;
for k in range(point_nums):
point = point_list[k]
result_point = [point[0,0], point[0,1], point[0,2]]
result_point_list.append(result_point)
result_contour_list.append(result_point_list)
result_roi_list.append([roi_name, result_contour_list])
return result_roi_list
def test_atributos_eh_consistente_ds_cheio(self):
'''Verifica se o atributo *_atributos* de Dataset eh consistente
quando *_dados* é não vazio'''
dados = np.zeros(shape=(5, 4))
ds = dm.Dataset(dados)
#o vetor de colunas é convertido para lista para ser possível a comparação
self.assertEquals(
pd.DataFrame(dados).columns.tolist(), ds.get_atributos())
def test_atualiza_atributos(self):
'''Verifica se o método atualiza_atributos atualiza os _atributos *_atributos*,
*_natributos* e *_ninstancias* quando *_dados* é modificado'''
ds = dm.Dataset()
dados = np.zeros(shape=(5, 4))
ds.set_dados(dados)
ds.atualiza_atributos()
#o vetor de colunas é convertido para lista para ser possível a comparação
self.assertEquals(
pd.DataFrame(dados).columns.tolist(), ds.get_atributos())
self.assertEquals(4, ds.get_natributos())
self.assertEquals(5, ds.get_ninstancias())
def load_dataset(category, path, validation_percentage, test_percentage):
dt = dd.Dataset(path, validation_percentage, test_percentage)
dt.split()
if category == 'train':
train_dataset = dt.get_train()
return train_dataset
elif category == 'validation':
validation_dataset = dt.get_validation()
return validation_dataset
else:
test_dataset = dt.get_test()
return test_dataset
def readDataset(metaFile, images_dir):
# Read metadata and split data in training and validation
metadata = meta.Metadata(metaFile, dtype=None)
trainingFilter = lambda df: df["Allele_Replicate"] <= 5
validationFilter = lambda df: df["Allele_Replicate"] > 5
metadata.splitMetadata(trainingFilter, validationFilter)
# Create a dataset
keyGen = lambda r: "{}/{}-{}".format(r["Metadata_Plate"], r[
"Metadata_Well"], r["Metadata_Site"])
dataset = ds.Dataset(metadata, "Allele", CHANNELS, images_dir, keyGen)
print(metadata.data.iloc[100])
return dataset
def compressBatch(args):
plate, imgsDir, statsDir, outDir = args
statsfile = statsDir + plate.data.iloc[0]["Metadata_Plate"] + ".pkl"
stats = pickle.load(open(statsfile, "rb"))
dataset = ds.Dataset(plate, "Allele", CHANNELS, imgsDir)
compress = px.Compress(stats, CHANNELS, outDir)
compress.setFormats(sourceFormat="tif", targetFormat="png")
compress.setScalingFactor(1.0)
compress.recomputePercentile(0.0001, side="lower")
compress.recomputePercentile(0.9999, side="upper")
compress.expected = dataset.numberOfRecords("all")
dataset.scan(compress.processImage, frame="all")
def test_ler_csv_existente_carrega_dataset(self):
'''Verifica se o método ler_csv le um arquivo csv existente e carrega
o atributo *_dados* corretamente'''
dados = np.zeros(shape=(5, 4))
df = pd.DataFrame(dados)
df.columns = [str(i) for i in df.columns
] #os nomes dos _atributos tem que ser strings
nomeArquivo = "teste.csv"
df.to_csv(nomeArquivo)
ds = dm.Dataset()
ds.ler_csv(nomeArquivo)
pdt.assert_frame_equal(
df, ds.get_dados()) #verifica se os dois dataframes são iguais
os.remove(nomeArquivo)
def intensityStats(args):
plate, root, outDir = args
plateName = plate.data["Metadata_Plate"].iloc[0]
dataset = ds.Dataset(plate, "Allele", CHANNELS, root)
hist = px.ImageStatistics(BITS,
CHANNELS,
DOWN_SCALE_FACTOR,
MEDIAN_FILTER_SIZE,
name=plateName)
hist.expected = dataset.numberOfRecords("all")
dataset.scan(hist.processImage, frame="all")
stats = hist.computeStats()
outfile = outDir + plateName + ".pkl"
with open(outfile, "wb") as output:
pickle.dump(stats, output)
return
def main(arguments):
data = dt.Dataset(dt.DATASET_FILE, dt.VOCAB_FILE)
input_data = np.asarray([[0, 1], [1, 0], [0, 0], [0, 1]])
input_shape = input_data[0].shape
print(input_data.shape)
intut = tf.keras.layers.Input(shape=input_shape)
#dnc = tf.keras.layers.Dense(32, activation="relu")(intut)
dnc = DenseDNC(2)(intut)
model = tf.keras.models.Model(inputs=intut, outputs=dnc)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['mae'])
model.summary()
def __init__(self):
self.initial_weight = cfg.EVAL.WEIGHT
self.time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))
self.moving_ave_decay = cfg.CONTFUSE.MOVING_AVE_DECAY
self.eval_logdir = "./data/logs/eval"
self.lidar_preprocessor = preprocess.LidarPreprocessor()
self.evalset = dataset.Dataset(self.lidar_preprocessor, 'test')
self.output_dir = cfg.EVAL.OUTPUT_PRED_PATH
self.img_anchors = loader.load_anchors(cfg.IMAGE.ANCHORS )
self.bev_anchors = loader.load_anchors(cfg.BEV.ANCHORS)
with tf.name_scope('model'):
self.model = contfuse_network.ContfuseNetwork()
self.net = self.model.load()
self.img_pred = self.net['img_pred']
self.bev_pred = self.net['bev_pred']
self.sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
self.saver = tf.train.Saver()#ema_obj.variables_to_restore())
self.saver.restore(self.sess, self.initial_weight)
def __init__(self):
self.initial_weight = cfg.EVAL.WEIGHT
self.time = time.strftime('%Y-%m-%d-%H-%M-%S',
time.localtime(time.time()))
self.moving_ave_decay = cfg.YOLOv2.MOVING_AVE_DECAY
self.eval_logdir = "./data/logs/eval"
self.evalset = dataset.Dataset('test')
self.output_dir = cfg.EVAL.OUTPUT_PRED_PATH
self.img_anchors = loader.load_anchors(cfg.IMG.ANCHORS)
with tf.name_scope('model'):
self.model = yolov2_network.YOLOv2Network()
self.net = self.model.load()
self.img_pred = self.net['img_pred']
config = ConfigProto()
config.gpu_options.allow_growth = True
self.sess = InteractiveSession(config=config)
self.saver = tf.train.Saver() #ema_obj.variables_to_restore())
self.saver.restore(self.sess, self.initial_weight)
self.timer = timer.Timer()
def test_ninstancias_eh_consistente_ds_vazio(self):
'''Verifica se o atributo *_ninstancias* de Dataset eh consistente
quando *_dados* é vazio'''
ds = dm.Dataset()
self.assertEquals(0, ds.get_ninstancias())
def main(args):
# s_ = time.time()
print(torch.cuda.get_device_properties(device=0).total_memory)
torch.cuda.empty_cache()
print(args)
save_dir = args.save_dir
mkdir_if_missing(save_dir)
num_txt = len(glob.glob(save_dir + "/*.txt"))
sys.stdout = logging.Logger(
os.path.join(save_dir, "log_" + str(num_txt) + ".txt"))
display(args)
start = 0
model = models.create(args.net,
pretrained=args.pretrained,
dim=args.dim,
self_supervision_rot=args.self_supervision_rot)
all_pretrained = glob.glob(save_dir + "/*.pth.tar")
if (args.resume is None) or (len(all_pretrained) == 0):
model_dict = model.state_dict()
else:
# resume model
all_pretrained_epochs = sorted(
[int(x.split("/")[-1][6:-8]) for x in all_pretrained])
args.resume = os.path.join(
save_dir, "ckp_ep" + str(all_pretrained_epochs[-1]) + ".pth.tar")
print('load model from {}'.format(args.resume))
chk_pt = load_checkpoint(args.resume)
weight = chk_pt['state_dict']
start = chk_pt['epoch']
model.load_state_dict(weight)
model = torch.nn.DataParallel(model)
model = model.cuda()
fake_centers_dir = os.path.join(args.save_dir, "fake_center.npy")
if np.sum(["train_1.txt" in x
for x in glob.glob(args.save_dir + "/**/*")]) == 0:
if args.rot_only:
create_fake_labels(None, None, args)
else:
data = dataset.Dataset(args.data,
ratio=args.ratio,
width=args.width,
origin_width=args.origin_width,
root=args.data_root,
self_supervision_rot=0,
mode="test",
rot_bt=args.rot_bt,
corruption=args.corruption,
args=args)
fake_train_loader = torch.utils.data.DataLoader(
data.train,
batch_size=100,
shuffle=False,
drop_last=False,
pin_memory=True,
num_workers=args.nThreads)
train_feature, train_labels = extract_features(
model,
fake_train_loader,
print_freq=1e5,
metric=None,
pool_feature=args.pool_feature,
org_feature=True)
create_fake_labels(train_feature, train_labels, args)
del train_feature
fake_centers = "k-means++"
torch.cuda.empty_cache()
elif os.path.exists(fake_centers_dir):
fake_centers = np.load(fake_centers_dir)
else:
fake_centers = "k-means++"
time.sleep(60)
model.train()
# freeze BN
if (args.freeze_BN is True) and (args.pretrained):
print(40 * '#', '\n BatchNorm frozen')
model.apply(set_bn_eval)
else:
print(40 * '#', 'BatchNorm NOT frozen')
# Fine-tune the model: the learning rate for pre-trained parameter is 1/10
new_param_ids = set(map(id, model.module.classifier.parameters()))
new_rot_param_ids = set()
if args.self_supervision_rot:
new_rot_param_ids = set(
map(id, model.module.classifier_rot.parameters()))
print(new_rot_param_ids)
new_params = [
p for p in model.module.parameters() if id(p) in new_param_ids
]
new_rot_params = [
p for p in model.module.parameters() if id(p) in new_rot_param_ids
]
base_params = [
p for p in model.module.parameters()
if (id(p) not in new_param_ids) and (id(p) not in new_rot_param_ids)
]
param_groups = [{
'params': base_params
}, {
'params': new_params
}, {
'params': new_rot_params,
'lr': args.rot_lr
}]
print('initial model is save at %s' % save_dir)
optimizer = torch.optim.Adam(param_groups,
lr=args.lr,
weight_decay=args.weight_decay)
criterion = losses.create(args.loss,
margin=args.margin,
alpha=args.alpha,
beta=args.beta,
base=args.loss_base).cuda()
data = dataset.Dataset(args.data,
ratio=args.ratio,
width=args.width,
origin_width=args.origin_width,
root=args.save_dir,
self_supervision_rot=args.self_supervision_rot,
rot_bt=args.rot_bt,
corruption=1,
args=args)
train_loader = torch.utils.data.DataLoader(
data.train,
batch_size=args.batch_size,
sampler=FastRandomIdentitySampler(data.train,
num_instances=args.num_instances),
drop_last=True,
pin_memory=True,
num_workers=args.nThreads)
# save the train information
for epoch in range(start, args.epochs):
train(epoch=epoch,
model=model,
criterion=criterion,
optimizer=optimizer,
train_loader=train_loader,
args=args)
if (epoch + 1) % args.save_step == 0 or epoch == 0:
if use_gpu:
state_dict = model.module.state_dict()
else:
state_dict = model.state_dict()
save_checkpoint({
'state_dict': state_dict,
'epoch': (epoch + 1),
},
is_best=False,
fpath=osp.join(
args.save_dir,
'ckp_ep' + str(epoch + 1) + '.pth.tar'))
if ((epoch + 1) % args.up_step == 0) and (not args.rot_only):
# rewrite train_1.txt file
data = dataset.Dataset(args.data,
ratio=args.ratio,
width=args.width,
origin_width=args.origin_width,
root=args.data_root,
self_supervision_rot=0,
mode="test",
rot_bt=args.rot_bt,
corruption=args.corruption,
args=args)
fake_train_loader = torch.utils.data.DataLoader(
data.train,
batch_size=args.batch_size,
shuffle=False,
drop_last=False,
pin_memory=True,
num_workers=args.nThreads)
train_feature, train_labels = extract_features(
model,
fake_train_loader,
print_freq=1e5,
metric=None,
pool_feature=args.pool_feature,
org_feature=(args.dim % 64 != 0))
fake_centers = create_fake_labels(train_feature,
train_labels,
args,
init_centers=fake_centers)
del train_feature
torch.cuda.empty_cache()
time.sleep(60)
np.save(fake_centers_dir, fake_centers)
# reload data
data = dataset.Dataset(
args.data,
ratio=args.ratio,
width=args.width,
origin_width=args.origin_width,
root=args.save_dir,
self_supervision_rot=args.self_supervision_rot,
rot_bt=args.rot_bt,
corruption=1,
args=args)
train_loader = torch.utils.data.DataLoader(
data.train,
batch_size=args.batch_size,
sampler=FastRandomIdentitySampler(
data.train, num_instances=args.num_instances),
drop_last=True,
pin_memory=True,
num_workers=args.nThreads)
# test on testing data
# extract_recalls(data=args.data, data_root=args.data_root, width=args.width, net=args.net, checkpoint=None,
# dim=args.dim, batch_size=args.batch_size, nThreads=args.nThreads, pool_feature=args.pool_feature,
# gallery_eq_query=args.gallery_eq_query, model=model)
model.train()
if (args.freeze_BN is True) and (args.pretrained):
print(40 * '#', '\n BatchNorm frozen')
model.apply(set_bn_eval)
# 参数
opt = config.MobileNetV3Config()
# 设置路径--保存训练产生的数据
date = time.strftime("%Y-%m-%d", time.localtime())
save_path = os.path.join(opt.checkpoints_path, date) # 保存的文件夹路径
os.makedirs(save_path, exist_ok=True)
log_filename = os.path.join(save_path, 'Console_Log.txt') # 日志路径
# 验证集
identity_list = dataset.get_lfw_list(opt.lfw_test_list)
lfw_img_paths = [os.path.join(opt.lfw_root, each) for each in identity_list] # 所有图片的路径
# 读取训练数据集
train_dataset = dataset.Dataset(opt.train_root, opt.path_split, phase='train', input_shape=opt.input_shape)
trainloader = data.DataLoader(train_dataset,
batch_size=opt.train_batch_size,
shuffle=True,
num_workers=opt.num_workers)
opt.num_classes = len(train_dataset.classes) # 分类数量
epoch_iters = len(trainloader) # 每个epoch里iter总个数
criterion = focal_loss.FocalLoss(gamma=2)
metric_fc = metrics.ArcMarginProduct(opt.embedding, opt.num_classes, s=64, m=0.5, easy_margin=opt.easy_margin)
# 加载模型
model = mobileNetV3_MixNet.MobileNetV3_MixNet(n_class=opt.embedding, input_size=opt.input_shape[2], dropout=opt.dropout_rate)
model.to(device)
model = DataParallel(model)
import numpy as np
import cv2
from data import dataset
from data import preprocess
from utils import vis_tools
from tqdm import tqdm
def project_fusionmap_to_img(img, fusionmap, down_ratio):
points = fusionmap[fusionmap[..., 0] > 0]
new_size = (int(img.shape[1] / down_ratio), int(img.shape[0] / down_ratio))
img = cv2.resize(img, new_size)
for p in points:
img[p[1]][p[0]] = 1.0
vis_tools.imshow_image(img)
vis_tools.imshow_image(fusionmap[..., 0].astype(np.float32))
if __name__ == "__main__":
lidar_preprocessor = preprocess.LidarPreprocessor()
trainset = dataset.Dataset(lidar_preprocessor, 'train')
pbar = tqdm(trainset)
for data in pbar:
img = data[1][0]
# print(img)
mapping1x = data[2][0]
mapping2x = data[3][0]
mapping4x = data[4][0]
mapping8x = data[5][0]
project_fusionmap_to_img(img, mapping1x, 1)
# vis_tools.imshow_image(img)
def Model2Feature(data,
net,
checkpoint,
dim=512,
width=224,
root=None,
nThreads=16,
batch_size=100,
pool_feature=False,
model=None,
org_feature=False,
args=None):
dataset_name = data
if model is None:
model = models.create(net, dim=dim, pretrained=False)
resume = checkpoint
model.load_state_dict(resume['state_dict'], strict=False)
model = torch.nn.DataParallel(model).cuda()
data = dataset.Dataset(data,
width=width,
root=root,
mode="test",
self_supervision_rot=0,
args=args)
if dataset_name in ['shop', 'jd_test', 'cifar']:
gallery_loader = torch.utils.data.DataLoader(data.gallery,
batch_size=batch_size,
shuffle=False,
drop_last=False,
pin_memory=True,
num_workers=nThreads)
query_loader = torch.utils.data.DataLoader(data.query,
batch_size=batch_size,
shuffle=False,
drop_last=False,
pin_memory=True,
num_workers=nThreads)
gallery_feature, gallery_labels = extract_features(
model,
gallery_loader,
print_freq=1e5,
metric=None,
pool_feature=pool_feature,
org_feature=org_feature)
query_feature, query_labels = extract_features(
model,
query_loader,
print_freq=1e5,
metric=None,
pool_feature=pool_feature,
org_feature=org_feature)
if org_feature:
norm = query_feature.norm(dim=1, p=2, keepdim=True)
query_feature = query_feature.div(norm.expand_as(query_feature))
print("feature normalized 1")
norm = gallery_feature.norm(dim=1, p=2, keepdim=True)
gallery_feature = gallery_feature.div(
norm.expand_as(gallery_feature))
print("feature normalized 2")
else:
data_loader = torch.utils.data.DataLoader(data.gallery,
batch_size=batch_size,
shuffle=False,
drop_last=False,
pin_memory=True,
num_workers=nThreads)
features, labels = extract_features(model,
data_loader,
print_freq=1e5,
metric=None,
pool_feature=pool_feature,
org_feature=org_feature)
if org_feature:
norm = features.norm(dim=1, p=2, keepdim=True)
features = features.div(norm.expand_as(features))
print("feature normalized")
gallery_feature, gallery_labels = query_feature, query_labels = features, labels
return gallery_feature, gallery_labels, query_feature, query_labels
def __init__(self):
self.learn_rate_init = cfg.TRAIN.LEARN_RATE_INIT
self.learn_rate_end = cfg.TRAIN.LEARN_RATE_END
self.first_stage_epochs = cfg.TRAIN.FRIST_STAGE_EPOCHS
self.second_stage_epochs = cfg.TRAIN.SECOND_STAGE_EPOCHS
self.warmup_periods = cfg.TRAIN.WARMUP_EPOCHS
self.initial_weight = cfg.TRAIN.PRETRAIN_WEIGHT
self.time = time.strftime('%Y-%m-%d-%H-%M-%S',
time.localtime(time.time()))
self.moving_ave_decay = cfg.YOLOv2.MOVING_AVE_DECAY
self.train_logdir = "./data/log/train"
self.trainset = dataset.Dataset('train')
self.valset = dataset.Dataset('val')
self.steps_per_period = len(self.trainset)
config = ConfigProto()
config.gpu_options.allow_growth = True
self.sess = InteractiveSession(config=config)
self.timer = timer.Timer()
# self.sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
with tf.name_scope('model'):
self.model = yolov2_network.YOLOv2Network()
self.net = self.model.load()
self.net_var = tf.global_variables()
self.loss = self.net["yolov2_loss"]
with tf.name_scope('learn_rate'):
self.global_step = tf.Variable(1.0,
dtype=tf.float64,
trainable=False,
name='global_step')
warmup_steps = tf.constant(self.warmup_periods *
self.steps_per_period,
dtype=tf.float64,
name='warmup_steps')
train_steps = tf.constant(
(self.first_stage_epochs + self.second_stage_epochs) *
self.steps_per_period,
dtype=tf.float64,
name='train_steps')
self.learn_rate = tf.cond(
pred=self.global_step < warmup_steps,
true_fn=lambda: self.global_step / warmup_steps * self.
learn_rate_init,
false_fn=lambda: self.learn_rate_end + 0.5 *
(self.learn_rate_init - self.learn_rate_end) * (1 + tf.cos(
(self.global_step - warmup_steps) /
(train_steps - warmup_steps) * np.pi)))
global_step_update = tf.assign_add(self.global_step, 1.0)
with tf.name_scope("define_weight_decay"):
moving_ave = tf.train.ExponentialMovingAverage(
self.moving_ave_decay).apply(tf.trainable_variables())
with tf.name_scope("define_first_stage_train"):
self.first_stage_trainable_var_list = []
for var in tf.trainable_variables():
var_name = var.op.name
var_name_mess = str(var_name).split('/')
if var_name_mess[0] in ["yolov2_headnet"]:
self.first_stage_trainable_var_list.append(var)
first_stage_optimizer = tf.train.AdamOptimizer(
self.learn_rate).minimize(
self.loss, var_list=self.first_stage_trainable_var_list)
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
with tf.control_dependencies(
[first_stage_optimizer, global_step_update]):
with tf.control_dependencies([moving_ave]):
self.train_op_with_frozen_variables = tf.no_op()
with tf.name_scope("define_second_stage_train"):
second_stage_trainable_var_list = tf.trainable_variables()
second_stage_optimizer = tf.train.AdamOptimizer(
self.learn_rate).minimize(
self.loss, var_list=second_stage_trainable_var_list)
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
with tf.control_dependencies(
[second_stage_optimizer, global_step_update]):
with tf.control_dependencies([moving_ave]):
self.train_op_with_all_variables = tf.no_op()
with tf.name_scope('loader_and_saver'):
self.loader = tf.train.Saver(self.net_var)
self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)
with tf.name_scope('summary'):
tf.summary.scalar("learn_rate", self.learn_rate)
tf.summary.scalar("yolov2_loss", self.net["yolov2_loss"])
tf.summary.scalar("img_obj_loss", self.net["img_obj_loss"])
tf.summary.scalar("img_cls_loss", self.net["img_cls_loss"])
tf.summary.scalar("img_bbox_loss", self.net["img_bbox_loss"])
logdir = "../logs/tensorboard"
if os.path.exists(logdir):
shutil.rmtree(logdir)
os.mkdir(logdir)
self.write_op = tf.summary.merge_all()
self.summary_writer = tf.summary.FileWriter(logdir,
graph=self.sess.graph)
img_pred_dir = cfg.YOLOv2.LOG_DIR + "/pred/img_pred/"
if os.path.exists(img_pred_dir):
shutil.rmtree(img_pred_dir)
os.mkdir(img_pred_dir)
prob = objness * clsness
cls_max_prob = np.max(prob, axis=-1)
cls_idx = np.argmax(prob, axis=-1)
bbox[..., :2] = bbox[..., :2]
bbox[..., 2:4] = bbox[..., 2:4]
x = (bbox[..., 0] + bbox[..., -4]) * cfg.IMG.STRIDE / cfg.IMG.H_SCALE_RATIO
y = (bbox[..., 1] + bbox[..., -3]) * cfg.IMG.STRIDE / cfg.IMG.W_SCALE_RATIO
h = bbox[..., 2] / cfg.IMG.H_SCALE_RATIO * bbox[:, -2]
w = bbox[..., 3] / cfg.IMG.W_SCALE_RATIO * bbox[:, -1]
left = y - w / 2
top = x - h / 2
right = y + w / 2
bottom = x + h / 2
result = np.stack([cls_idx, cls_max_prob, left, top, right, bottom],
axis=-1)
return result[cls_max_prob > 0.3]
trainset = dataset.Dataset('train')
img_anchors = trainset.img_anchors
img_dir = os.path.join(cfg.YOLOv2.DATASETS_DIR, "image_files/")
for j in range(len(trainset)):
data = trainset.load()
# vis_tools.imshow_img(data[0][0].astype(np.float32))
shape = [cfg.IMG.OUTPUT_H, cfg.IMG.OUTPUT_W, cfg.IMG.LABEL_Z]
label = np.reshape(data[1][0], shape)
imglabel = parse_img_labelmap(label, img_anchors)
img_bboxes = postprocess.img_nms(imglabel, cfg.IMG.IOU_THRESHOLDS)
vis_tools.imshow_img_bbox(data[0][0].astype(np.float32), img_bboxes)
def test_ler_csv_nao_existente(self):
'''Verifica se o método ler_csv retorna Falso quando o recebe o
nome de um arquivo csv inexiste'''
ds = dm.Dataset()
self.assertFalse(ds.ler_csv("blah.csv"))
def test_remover_atributo_existente(self):
'''Verifica se o método remover_atributo remove um atributo existente'''
dados = np.zeros(shape=(5, 4))
ds = dm.Dataset(dados)
ds.remover_atributos([1])
self.assertFalse(1 in ds.get_atributos())
def test_remover_atributo_inexistente(self):
'''Verifica se o método remover_atributo avisa sobre um atributo inexistente'''
dados = np.zeros(shape=(5, 4))
ds = dm.Dataset(dados)
self.assertFalse(ds.remover_atributos([8]))
def test_dados_eh_dataframe(self):
'''Verifica se o atributo *_dados* é do tipo pandas.DataFrame'''
ds = dm.Dataset()
self.assertIsInstance(ds.get_dados(), pd.DataFrame)
def save_model(model, save_path, name, iter_cnt):
save_name = os.path.join(save_path, name + '_' + str(iter_cnt) + '.pth')
torch.save(model.state_dict(), save_name)
return save_name
if __name__ == '__main__':
opt = config.Config()
if opt.display:
visualizer = Visualizer()
device = torch.device("cuda")
train_dataset = dataset.Dataset(
opt.train_root, # '/data/Datasets/webface/CASIA-maxpy-clean-crop-144/'
opt.train_list, # '/data/Datasets/webface/train_data_13938.txt'
phase='train',
input_shape=opt.input_shape # (1, 128, 128)
)
trainloader = data.DataLoader(
train_dataset,
batch_size=opt.train_batch_size, # 16
shuffle=True,
num_workers=opt.num_workers # 4
)
identity_list = test.get_lfw_list(opt.lfw_test_list)
img_paths = [os.path.join(opt.lfw_root, each) for each in identity_list]
print('{} train iters per epoch:'.format(len(trainloader)))
1 / 0
def test_ninstancias_eh_consistentes_ds_cheio(self):
'''Verifica se o atributo *_ninstancias* de Dataset eh consistente
quando *_dados* é não vazio'''
dados = np.zeros(shape=(5, 4))
ds = dm.Dataset(dados)
self.assertEquals(5, ds.get_ninstancias())
