def __init__(self,
root,
tsv_path,
labels_to_idx,
num_classes=56,
spect_len=4096,
train=True):
self.train = train
self.root = root
self.num_classes = num_classes
self.spect_len = spect_len
self.labels_to_idx = labels_to_idx
self.prepare_data(tsv_path)
if train:
self.transform = get_transforms(train=True,
size=spect_len,
wrap_pad_prob=0.5,
resize_scale=(0.8, 1.0),
resize_ratio=(1.7, 2.3),
resize_prob=0.33,
spec_num_mask=2,
spec_freq_masking=0.15,
spec_time_masking=0.20,
spec_prob=0.5)
else:
self.transform = get_transforms(False, spect_len)
def run(config_file):
config = load_config(config_file)
os.makedirs(config.work_dir, exist_ok=True)
save_config(config, config.work_dir + '/config.yml')
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
all_transforms = {}
all_transforms['train'] = get_transforms(config.transforms.train)
all_transforms['valid'] = get_transforms(config.transforms.test)
dataloaders = {
phase: make_loader(
data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase=phase,
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=all_transforms[phase],
num_classes=config.data.num_classes,
pseudo_label_path=config.train.pseudo_label_path,
task='cls'
)
for phase in ['train', 'valid']
}
# create model
model = CustomNet(config.model.encoder, config.data.num_classes)
# train setting
criterion = get_loss(config)
params = [
{'params': model.base_params(), 'lr': config.optimizer.params.encoder_lr},
{'params': model.fresh_params(), 'lr': config.optimizer.params.decoder_lr}
]
optimizer = get_optimizer(params, config)
scheduler = get_scheduler(optimizer, config)
# model runner
runner = SupervisedRunner(model=model)
callbacks = [MultiClassAccuracyCallback(threshold=0.5), F1ScoreCallback()]
if os.path.exists(config.work_dir + '/checkpoints/best.pth'):
callbacks.append(CheckpointCallback(resume=config.work_dir + '/checkpoints/best_full.pth'))
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=dataloaders,
logdir=config.work_dir,
num_epochs=config.train.num_epochs,
callbacks=callbacks,
verbose=True,
fp16=True,
)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--dir_root", type=Path, required=True,
help="Root directory for train. Contains the VOCdevkit dir")
args = parser.parse_args()
dir_root = args.dir_root
if not dir_root.is_dir():
raise ValueError(f"Not a directory: {dir_root}")
dataset = NipponDataset(dir_root, transform=get_transforms(img_size=416))
print("Size of dataset: ", len(dataset))
training_generator = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=False, collate_fn=collate_fn)
for idx, batch in enumerate(training_generator):
images, labels = batch
img_bbox = []
for img_idx, img in enumerate(images):
# single image and its label
label_xyxy = utils.select_bbox_from_img_id(labels, img_idx)
img = draw_bbox(img, label_xyxy)
img_bbox.append(img)
concat_img = np.concatenate(img_bbox, axis=1)
cv2.imwrite(f"output/dataset_sample_batch_{idx}.jpg", concat_img)
if idx >= 1:
break
def __init__(self, mode='train', transform_type=None, val_split=0.3, seed=42):
"""Base class for three MNIST tasks
Keyword Arguments:
mode {str} -- initialize dataset for training, validation, or test (default: {'train'})
transform_type {str} -- one of 'R', 'RTS', 'P', 'E', 'T', or 'TU' (default: {None})
val_split {float} -- ratio for validation (default: {0.3})
seed {int} -- seed for generating the same training or validation dataset (default: {42})
"""
assert mode in ['train', 'val', 'test']
super(BaseMNIST, self).__init__()
train = mode in ['train', 'val']
self.mode = mode
self.pre_transform, self.post_transform, self.cluster_transform = get_transforms(type=transform_type)
self.mnist = prepare_mnist(train=train, transform=self.pre_transform)
np.random.seed(seed)
index_list = list(range(len(self.mnist)))
index_list = np.random.permutation(index_list)
if train:
split = int(len(self.mnist) * (1 - val_split))
if self.mode == 'train':
self.index_list = index_list[:split]
elif self.mode == 'val':
self.index_list = index_list[split:]
else:
self.index_list = index_list
def run_cls(config_file_cls):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_cls)
validloader = make_loader(data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase='valid',
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=get_transforms(
config.transforms.test),
num_classes=config.data.num_classes,
task='cls')
model = CustomNet(config.model.encoder, config.data.num_classes)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_predictions = []
all_targets = []
with torch.no_grad():
for i, (batch_images, batch_targets) in enumerate(tqdm(validloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_targets.append(batch_targets)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
all_targets = np.concatenate(all_targets)
# evaluation
all_accuracy_scores = []
all_f1_scores = []
thresholds = np.linspace(0.1, 0.9, 9)
for th in thresholds:
accuracy = accuracy_score(all_targets > th, all_predictions > th)
f1 = f1_score(all_targets > th,
all_predictions > th,
average='samples')
all_accuracy_scores.append(accuracy)
all_f1_scores.append(f1)
for th, score in zip(thresholds, all_accuracy_scores):
print('validation accuracy for threshold {} = {}'.format(th, score))
for th, score in zip(thresholds, all_f1_scores):
print('validation f1 score for threshold {} = {}'.format(th, score))
np.save('valid_preds', all_predictions)
def run(config_file, fold=0, device_id=0, ensemble=False):
os.environ['CUDA_VISIBLE_DEVICES'] = str(device_id)
config = load_config(config_file)
if not '_fold' in config.work_dir and not ensemble:
config.work_dir = config.work_dir + '_fold{}'.format(fold)
testloader = make_loader(
data_dir=config.data.test_dir,
df_path=config.data.sample_submission_path,
features=config.data.features,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test),
)
if ensemble:
# load model
models = []
for c in model_config_paths:
for i in range(5):
models.append(load_fold_model(c, i))
model = MultiModels(models, tta=False)
else:
checkpoint_path = config.work_dir + '/checkpoints/best.pth'
model = load_model(config_file, checkpoint_path, fold)
predictions = []
z_pos = config.data.z_pos[0]
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = model(batch_images.to(config.device))
batch_preds[:, 0] = torch.sigmoid(batch_preds[:, 0])
batch_preds[:, z_pos] = depth_transform(batch_preds[:, z_pos])
batch_preds = batch_preds.data.cpu().numpy()
for preds in batch_preds:
coords = extract_coords(
preds,
features=config.data.features,
img_size=(config.data.height, config.data.width),
confidence_threshold=config.test.confidence_threshold,
distance_threshold=config.test.distance_threshold,
)
s = coords2str(coords)
predictions.append(s)
# ---------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
test = pd.read_csv(config.data.sample_submission_path)
test['PredictionString'] = predictions
out_path = config.work_dir + '/submission.csv'
test.to_csv(out_path, index=False)
postprocess(out_path)
def get_raw_geom(i, lim=None):
if isinstance(i, str):
from mcrp_splitters import InputSplitter
i = InputSplitter(i)
# read cells, surfaces and transformations from input
cells = get_cells(i, lim=lim)
surfs = get_surfaces(i)
trans = get_transforms(i)
return cells, surfs, trans
def predict():
torch.manual_seed(0)
np.random.seed(0)
print("Create data loaders", flush=True)
print("Input size : " + str(args.input_size))
print("Model : fixpnasnet5large")
# 载入数据
transformation = get_transforms(input_size=args.input_size,
test_size=args.input_size,
kind='full',
crop=True,
need=('train', 'val'),
backbone='pnasnet5large')
transform_test = transformation['val']
test_set = datasets.ImageFolder(args.tempdata, transform=transform_test)
test_loader = torch.utils.data.DataLoader(
test_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=(args.workers - 1),
)
# 载入模型
model = pnasnet5large(pretrained='imagenet')
pretrained_dict = torch.load(args.model_path, map_location='cpu')['model']
model_dict = model.state_dict()
count = 0
count2 = 0
for k in model_dict.keys():
count = count + 1.0
if (('module.' + k) in pretrained_dict.keys()):
count2 = count2 + 1.0
model_dict[k] = pretrained_dict.get(('module.' + k))
model.load_state_dict(model_dict)
print("load " + str(count2 * 100 / count) + " %")
assert int(count2 * 100 / count) == 100, "model loading error"
for name, child in model.named_children():
for name2, params in child.named_parameters():
params.requires_grad = False
print('model_load')
if torch.cuda.is_available():
model.cuda(0)
model.eval()
predlist = []
with torch.no_grad():
for data in tqdm.tqdm(test_loader):
images, labels = data
images = images.cuda(0, non_blocking=True)
outputs = model(images)
pred = torch.argmax(outputs, dim=1)
npred = pred.cpu().numpy()
predlist.extend(list(npred))
return predlist
def datasets(self):
train_datasets = Dataset(
images_dir=self.images_path,
# image_size=self.image_size,
subset="train", # train
transform=get_transforms(train=True),
is_resize=self.is_resize,
image_short_side=self.image_short_side,
is_padding=self.is_padding)
# valid_datasets = train_datasets
valid_datasets = Dataset(
images_dir=self.images_path,
# image_size=self.image_size,
subset="validation", # validation
transform=get_transforms(train=False),
is_resize=self.is_resize,
image_short_side=self.image_short_side,
is_padding=False)
return train_datasets, valid_datasets
def run_cls(config_dir):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config_root = Path(config_dir) / 'cls'
config_paths = [config_root / p for p in os.listdir(config_root)]
base_config_paths = [
Path(config_dir) / p for p in os.listdir(config_dir) if 'yml' in p
]
config = load_config(base_config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiClsModels(models)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
all_fnames = []
all_predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_fnames.extend(batch_fnames)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
np.save('all_preds', all_predictions)
df = pd.DataFrame(data=all_predictions, index=all_fnames)
df.to_csv('cls_preds.csv')
df.to_csv(KAGGLE_WORK_DIR + '/cls_preds.csv')
def run_cls(config_file_cls):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 1. classification inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_cls)
model = CustomNet(config.model.encoder, config.data.num_classes)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_fnames = []
all_predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta,
task='cls')
all_fnames.extend(batch_fnames)
all_predictions.append(batch_preds)
all_predictions = np.concatenate(all_predictions)
np.save('all_preds', all_predictions)
df = pd.DataFrame(data=all_predictions, index=all_fnames)
df.to_csv('cls_preds.csv', index=False)
df.to_csv(f"{config.work_dir}/cls_preds.csv", index=False)
def get_model_and_loader(config_paths):
config = load_config(config_paths[0])
models = []
for c in config_paths:
models.append(load_model(c))
model = MultiSegModels(models)
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
return model, testloader
def get_image_dataloader(df,
get_x='file_path',
batch_size=1,
shuffle=False,
num_workers=0):
"""
Provides an iterable over the given dataset.
:param df (pd.DataFrame): dataframe from which to load the data.
:param get_x (str): column name in given dataframe which contains file path to images.
:param batch_size (int): how many samples per batch to load (default: 1).
:param shuffle (boolean): set to True to have the data reshuffled at every epoch (default: False).
:param num_workers (int): how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.
:return: torch.utils.data.DataLoader
"""
dataset = FaceCupDataset(df=df, get_x=get_x, trans=get_transforms())
return DataLoader(dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_workers)
def test_forward():
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(
pretrained=True)
root = "/Users/cjw/Desktop/SeanMovie"
image_dir = "Images"
mask_dir = "Masks"
pdataset = PombeDataset(root, image_dir, mask_dir,
transforms.get_transforms())
data_loader = torch.utils.data.DataLoader(pdataset,
batch_size=3,
shuffle=True,
num_workers=2,
collate_fn=collate)
images, targets = next(iter(data_loader))
images = list(image for image in images)
targets = [{k: v for k, v in t.items()} for t in targets]
#output = model(images, targets)
model.eval()
xi, xt = pdataset.__getitem__(1)
print(xi.shape)
predictions = model(3 * [xi])
return predictions
def load_data(root,
batch_size,
train_split='train',
val_split='val',
class2ind_file='object_class2ind',
use_objects=True,
use_parts=False,
return_separate_targets=False,
part_class2ind_file=None,
num_workers=0,
max_samples=None):
"""
`load train/val data loaders and class2ind (dict), n_classes (int)`
Args:
root (string): Root directory of the Pascal Part Dataset. Must contain the fololowing dir structure:
Images: `root`/JPEGImages/*.jpg
Object and Part annotations: `root`/Annotations_Part_json/*.json [see `parse_Pascal_VOC_Part_Anno.py`]
train/val splits: `root`/ImageSets/Main/`image_set`.txt
class2ind_file: `root`/Classes/`class2ind_file`.txt
batch_size: batch size for training
train/val splits: `root`/ImageSets/Main/`image_set`.txt
class2ind_file: file containing list of class names and class index that are to be considered from all annotations.
Other object/part classes will be ignored.
Default: `object_class2ind`.
Note: `__background__` class should also be present.
use_objects: if True (default=True), use object annotations
use_parts: if True (default=False), use part annotations that are present inside an object
return_separate_targets: if True, return img, obj_target, part_target instead of img, target (default: False)
should be set True only for training JointDetector
part_class2ind_file: similar to `class2ind_file` but will have part classes (default: None).
should be provided only if return_separate_targets=True otherwise should be provided as `class2ind_file`.
max_samples: maximum number of samples for train/val datasets. (Default: None)
Can be set to a small number for faster training
"""
train_dataset = PascalPartVOCDetection(
root,
train_split,
get_transforms(is_train=True),
class2ind_file=class2ind_file,
use_objects=use_objects,
use_parts=use_parts,
return_separate_targets=return_separate_targets,
part_class2ind_file=part_class2ind_file)
val_dataset = PascalPartVOCDetection(
root,
val_split,
get_transforms(is_train=False),
class2ind_file=class2ind_file,
use_objects=use_objects,
use_parts=use_parts,
return_separate_targets=return_separate_targets,
part_class2ind_file=part_class2ind_file)
class2ind = train_dataset.class2ind
n_classes = train_dataset.n_classes
if return_separate_targets:
part_class2ind = train_dataset.part_class2ind
part_n_classes = train_dataset.part_n_classes
if max_samples is not None:
train_dataset = data.Subset(train_dataset, np.arange(max_samples))
val_dataset = data.Subset(val_dataset, np.arange(max_samples))
train_loader = data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
collate_fn=collate_fn,
drop_last=True)
val_loader = data.DataLoader(val_dataset,
batch_size=1,
shuffle=False,
num_workers=num_workers,
collate_fn=collate_fn)
if return_separate_targets:
return train_loader, val_loader, class2ind, n_classes, part_class2ind, part_n_classes
return train_loader, val_loader, class2ind, n_classes
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
model = getattr(smp, config.model.arch)(
encoder_name=config.model.encoder,
encoder_weights=config.model.pretrained,
classes=config.data.num_classes,
activation=None,
)
if os.path.exists('cls_preds.csv'):
testloader = make_loader(data_folder=config.data.test_dir,
df_path='cls_preds.csv',
phase='filtered_test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
else:
testloader = make_loader(data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(
config.transforms.test))
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
if os.path.exists(config.work_dir + '/threshold_search.json'):
with open(config.work_dir + '/threshold_search.json') as json_file:
data = json.load(json_file)
df = pd.DataFrame(data)
min_sizes = list(df.T.idxmax().values.astype(int))
print('load best threshold from validation:', min_sizes)
else:
min_sizes = config.test.min_size
print('load default threshold:', min_sizes)
predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
for fname, preds in zip(batch_fnames, batch_preds):
if config.data.num_classes == 4:
for cls in range(preds.shape[0]):
mask = preds[cls, :, :]
mask, num = post_process(mask,
config.test.best_threshold,
min_sizes[cls])
rle = mask2rle(mask)
name = fname + f"_{cls + 1}"
predictions.append([name, rle])
else: # == 5
for cls in range(1, 5):
mask = preds[cls, :, :]
mask, num = post_process(mask,
config.test.best_threshold,
min_sizes[cls])
rle = mask2rle(mask)
name = fname + f"_{cls}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
df = pd.DataFrame(predictions,
columns=['ImageId_ClassId', 'EncodedPixels'])
df.to_csv(config.work_dir + "/submission.csv", index=False)
pred_scores_list.append(p['scores'])
evalutor.update(pred_boxes_list, pred_scores_list,
gt_boxes_list)
log = '[Validation]Epoch: [{}]\t{}'.format(epoch,
evalutor.get_log_str())
print(log)
return evalutor.f1_score
if __name__ == '__main__':
args = parse_args()
log_file = open(args.logs, 'w', encoding='utf-8')
train_dataset = ANIMEDataset(labeled_file=args.train_labeled_file,
img_dir=args.img_dir,
transforms=get_transforms(True),
long_size=args.long_size)
val_dataset = ANIMEDataset(labeled_file=args.val_labeled_file,
img_dir=args.img_dir,
transforms=get_transforms(False),
long_size=args.long_size)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.works,
collate_fn=collate_fn)
val_loader = DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.works,
def train(traindic, valdic):
model = models.resnet18(pretrained=False)
# print(model.state_dict().keys())
fc_features = model.fc.in_features
num_classes = len(traindic)
model.fc = nn.Linear(fc_features, num_classes)
transformation = get_transforms(input_size=224,
test_size=224,
kind='full',
crop=True,
need=('train', 'val'))
transform_train = transformation['train']
transform_test = transformation['val']
train_dataset = datasets.ImageFolder(args.traindata,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(train_dataset,
batch_size=64,
shuffle=True,
num_workers=2)
val_dataset = datasets.ImageFolder(args.valdata + 'val',
transform=transform_test)
valloader = torch.utils.data.DataLoader(val_dataset,
batch_size=100,
shuffle=False,
num_workers=2)
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
print('using gpu:', 1)
if torch.cuda.is_available():
torch.backends.cudnn.benchmark = True
net = model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(),
lr=0.005,
momentum=0.9,
weight_decay=5e-4)
best_acc = 0.85 # 2 初始化best test accuracy
print("Start Training, Resnet-18!") # 定义遍历数据集的次数
for epoch in range(1, 101): # 从先前次数开始训练
print('\nEpoch: %d' % (epoch + 1)) # 输出当前次数
net.train()
sum_loss = 0.0 # 损失数量
correct = 0.0 # 准确数量
total = 0.0 # 总共数量
for i, data in enumerate(trainloader, 0):
length = len(trainloader)
inputs, labels = data
inputs, labels = inputs.cuda(), labels.cuda()
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
sum_loss += loss.item()
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += predicted.eq(labels.data).cpu().sum()
co = correct.numpy().tolist()
print('[epoch:%d, iter:%d] Loss: %.03f | Acc: %.3f ' %
(epoch + 1, (i + 1 + epoch * length), sum_loss /
(i + 1), 100 * co / total))
# 每训练完一个epoch测试一下准确率
print("Waiting Test!")
predlist = []
labelist = []
with torch.no_grad(): # 没有求导
for data in valloader:
net.eval(
) # 运用net.eval()时，由于网络已经训练完毕，参数都是固定的，因此每个min-batch的均值和方差都是不变的，因此直接运用所有batch的均值和方差。
images, labels = data
images, labels = images.cuda(), labels.cuda()
outputs = net(images)
# 取得分最高的那个类 (outputs.data的索引号)
_, predicted = torch.max(outputs.data, 1)
npred = predicted.cpu().numpy()
predlist.extend(list(npred))
nlabel = labels.cpu().numpy()
labelist.extend(nlabel)
pred = [traindic[j] for j in predlist]
label = [valdic[j] for j in labelist]
total = len(pred)
co = 0
for i in range(total):
if pred[i] == label[i]:
co += 1
print('测试分类准确率为：%.3f%%' % (100. * co / total))
acc = 100. * co / total
if acc > best_acc:
print('Saving model......')
torch.save(net.state_dict(), './model/resnet18.pth')
best_acc = acc
print("Training Finished, TotalEPOCH=%d" % 100)
with open('acc.txt', 'a') as f:
f.writelines(best_acc)
parser.add_argument("--conf_thres", type=float, default=0.8, help="object confidence threshold")
parser.add_argument("--nms_thres", type=float, default=0.4, help="iou thresshold for non-maximum suppression")
parser.add_argument("--batch_size", type=int, default=8, help="batch size")
opt = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup model
model = Darknet(opt.model_def, img_size=416).to(device)
# Load weights
if opt.weights_path is not None:
if opt.weights_path.endswith('.weights'):
# Load original author's darknet weights
print('Loading darknet weights')
model.load_darknet_weights(opt.weights_path)
else:
# Load our training checkpoint weights
print('Loading trained checkpoint')
model.load_state_dict(torch.load(opt.weights_path))
# dataloader
root_test = opt.root_test
dataset_test = RGBOnly(root_test, transform=get_transforms(img_size=416))
conf_thres = opt.conf_thres
nms_thres = opt.nms_thres
batch_size = opt.batch_size
testloader = torch.utils.data.DataLoader(dataset_test, batch_size=batch_size, shuffle=False, num_workers=1)
inference_visualize(model, testloader, device, conf_thres=conf_thres, nms_thres=nms_thres)
def run(config_file):
config = load_config(config_file)
if not os.path.exists(config.work_dir):
os.makedirs(config.work_dir, exist_ok=True)
save_config(config, config.work_dir + '/config.yml')
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
all_transforms = {}
all_transforms['train'] = get_transforms(config.transforms.train)
all_transforms['valid'] = get_transforms(config.transforms.test)
dataloaders = {
phase: make_loader(data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase=phase,
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=all_transforms[phase],
num_classes=config.data.num_classes,
pseudo_label_path=config.train.pseudo_label_path,
debug=config.debug)
for phase in ['train', 'valid']
}
# create segmentation model with pre trained encoder
model = getattr(smp, config.model.arch)(
encoder_name=config.model.encoder,
encoder_weights=config.model.pretrained,
classes=config.data.num_classes,
activation=None,
)
# train setting
criterion = get_loss(config)
params = [
{
'params': model.decoder.parameters(),
'lr': config.optimizer.params.decoder_lr
},
{
'params': model.encoder.parameters(),
'lr': config.optimizer.params.encoder_lr
},
]
optimizer = get_optimizer(params, config)
scheduler = get_scheduler(optimizer, config)
# model runner
runner = SupervisedRunner(model=model)
callbacks = [DiceCallback(), IouCallback()]
# to resume from check points if exists
if os.path.exists(config.work_dir + '/checkpoints/best.pth'):
callbacks.append(
CheckpointCallback(resume=config.work_dir +
'/checkpoints/best_full.pth'))
if config.train.mixup:
callbacks.append(MixupCallback())
if config.train.cutmix:
callbacks.append(CutMixCallback())
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=dataloaders,
logdir=config.work_dir,
num_epochs=config.train.num_epochs,
callbacks=callbacks,
verbose=True,
fp16=True,
)
def run(config_file, device_id, idx_fold):
os.environ['CUDA_VISIBLE_DEVICES'] = str(device_id)
print('info: use gpu No.{}'.format(device_id))
config = load_config(config_file)
# for n-folds loop
if config.data.params.idx_fold == -1:
config.data.params.idx_fold = idx_fold
config.work_dir = config.work_dir + '_fold{}'.format(idx_fold)
elif config.data.params.idx_fold == 0:
original_fold = int(config.work_dir.split('_fold')[1])
if original_fold == idx_fold:
raise Exception(
'if you specify fold 0, you should use train.py or resume from fold 1.'
)
config.data.params.idx_fold = idx_fold
config.work_dir = config.work_dir.split('_fold')[0] + '_fold{}'.format(
idx_fold)
else:
raise Exception('you should use train.py if idx_fold is specified.')
print('info: training for fold {}'.format(idx_fold))
if not os.path.exists(config.work_dir):
os.makedirs(config.work_dir, exist_ok=True)
all_transforms = {}
all_transforms['train'] = get_transforms(config.transforms.train)
all_transforms['valid'] = get_transforms(config.transforms.test)
dataloaders = {
phase: make_loader(
df_path=config.data.train_df_path,
data_dir=config.data.train_dir,
features=config.data.features,
phase=phase,
img_size=(config.data.height, config.data.width),
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=all_transforms[phase],
horizontal_flip=config.train.horizontal_flip,
model_scale=config.data.model_scale,
debug=config.debug,
pseudo_path=config.data.pseudo_path,
)
for phase in ['train', 'valid']
}
# create segmentation model with pre trained encoder
num_features = len(config.data.features)
print('info: num_features =', num_features)
model = CenterNetFPN(
slug=config.model.encoder,
num_classes=num_features,
)
optimizer = get_optimizer(model, config)
scheduler = get_scheduler(optimizer, config)
# model runner
runner = SupervisedRunner(model=model, device=get_device())
# train setting
criterion, callbacks = get_criterion_and_callback(config)
if config.train.early_stop_patience > 0:
callbacks.append(
EarlyStoppingCallback(patience=config.train.early_stop_patience))
if config.train.accumulation_size > 0:
accumulation_steps = config.train.accumulation_size // config.train.batch_size
callbacks.extend(
[OptimizerCallback(accumulation_steps=accumulation_steps)])
# to resume from check points if exists
if os.path.exists(config.work_dir + '/checkpoints/last_full.pth'):
callbacks.append(
CheckpointCallback(resume=config.work_dir +
'/checkpoints/last_full.pth'))
# model training
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=dataloaders,
logdir=config.work_dir,
num_epochs=config.train.num_epochs,
main_metric=config.train.main_metric,
minimize_metric=config.train.minimize_metric,
callbacks=callbacks,
verbose=True,
fp16=config.train.fp16,
)
def main(args):
args = parse_args(args)
exp_name = Path(f"./exp/{args.exp_name}")
assert exp_name.exists()
# load config
with open(exp_name / "config.yaml") as f:
cfg = yaml.safe_load(f)
test_df = pd.read_csv(args.test_meta, header=0, sep="\t")
n_frames = math.ceil(cfg["max_len_seconds"] *
cfg["feature"]["sample_rate"] /
cfg["feature"]["mel_spec"]["hop_size"])
# Note: assume that the same class used in the training is included at least once.
classes = test_df.event_label.dropna().sort_values().unique()
many_hot_encoder = ManyHotEncoder(labels=classes, n_frames=n_frames)
encode_function = many_hot_encoder.encode_strong_df
feat_dir = Path(
f"data/feat/sr{cfg['feature']['sample_rate']}_n_mels{cfg['feature']['mel_spec']['n_mels']}_"
+
f"n_fft{cfg['feature']['mel_spec']['n_fft']}_hop_size{cfg['feature']['mel_spec']['hop_size']}"
)
stats = np.load(f"exp/{cfg['exp_name']}/stats.npz", )
norm_dict_params = {
"mean": stats["mean"],
"std": stats["std"],
"mode": cfg["norm_mode"],
}
test_transforms = get_transforms(
cfg["data_aug"],
nb_frames=n_frames,
norm_dict_params=norm_dict_params,
training=False,
prob=0.0,
)
test_dataset = SEDDataset(
test_df,
data_dir=feat_dir / "public",
encode_function=encode_function,
pooling_time_ratio=cfg["pooling_time_ratio"],
transforms=test_transforms,
)
if cfg["ngpu"] > 1:
cfg["batch_size"] *= cfg["ngpu"]
test_loader = DataLoader(
test_dataset,
batch_size=cfg["batch_size"],
shuffle=False,
num_workers=cfg["num_workers"],
pin_memory=True,
)
# logging info
if args.verbose > 0:
logging.basicConfig(
level=logging.INFO,
format=
"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
else:
logging.basicConfig(
level=logging.WARN,
format=
"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
logging.warning("Skip DEBUG/INFO messages")
# display PYTHONPATH
logging.info("python path = " + os.environ.get("PYTHONPATH", "(None)"))
seed_everything(cfg["seed"])
model = SEDModel(n_class=10,
cnn_kwargs=cfg["model"]["cnn"],
encoder_kwargs=cfg["model"]["encoder"])
checkpoint = torch.load(exp_name / "model" / "model_best_score.pth")
model.load_state_dict(checkpoint["state_dict"])
trainer_options = MeanTeacherTrainerOptions(**cfg["trainer_options"])
trainer_options._set_validation_options(
valid_meta=args.test_meta,
valid_audio_dir=args.test_audio_dir,
max_len_seconds=cfg["max_len_seconds"],
sample_rate=cfg["feature"]["sample_rate"],
hop_size=cfg["feature"]["mel_spec"]["hop_size"],
pooling_time_ratio=cfg["pooling_time_ratio"],
)
output_dir = exp_name / "test"
output_dir.mkdir(exist_ok=True)
with open(exp_name / "post_process_params.pickle", "rb") as f:
pp_params = pickle.load(f)
model = model.to(trainer_options.device)
test(model, test_loader, output_dir, trainer_options, pp_params=pp_params)
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
validloader = make_loader(
data_folder=config.data.train_dir,
df_path=config.data.train_df_path,
phase='valid',
batch_size=config.train.batch_size,
num_workers=config.num_workers,
idx_fold=config.data.params.idx_fold,
transforms=get_transforms(config.transforms.test),
num_classes=config.data.num_classes,
)
# create segmentation model with pre-trained encoder
model = getattr(smp, config.model.arch)(
encoder_name=config.model.encoder,
encoder_weights=config.model.pretrained,
classes=config.data.num_classes,
activation=None,
)
model.to(config.device)
model.eval()
checkpoint = load_checkpoint(f"{config.work_dir}/checkpoints/best.pth")
model.load_state_dict(checkpoint['model_state_dict'])
all_dice = {}
min_sizes = [100, 300, 500, 750, 1000, 1500, 2000, 3000]
for min_size in min_sizes:
all_dice[min_size] = {}
for cls in range(config.data.num_classes):
all_dice[min_size][cls] = []
with torch.no_grad():
for i, (batch_images, batch_masks) in enumerate(tqdm(validloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
batch_masks = batch_masks.cpu().numpy()
for masks, preds in zip(batch_masks, batch_preds):
for cls in range(config.data.num_classes):
for min_size in min_sizes:
pred, _ = post_process(preds[cls, :, :],
config.test.best_threshold,
min_size)
mask = masks[cls, :, :]
all_dice[min_size][cls].append(dice_score(pred, mask))
for cls in range(config.data.num_classes):
for min_size in min_sizes:
all_dice[min_size][cls] = sum(all_dice[min_size][cls]) / len(
all_dice[min_size][cls])
dict_to_json(all_dice, config.work_dir + '/threshold_search.json')
if config.data.num_classes == 4:
defect_class = cls + 1
else:
defect_class = cls
print('average dice score for class{} for min_size {}: {}'.format(
defect_class, min_size, all_dice[min_size][cls]))
def main():
#TODO: Get args
# python3 train_fixmatch.py --checkpoint-path ./checkpoint_path/model.pth --batch-size 1 --num-epochs 1 --num-steps 1 --train-from-start 1 --dataset-folder ./dataset
parser = argparse.ArgumentParser()
parser.add_argument('--checkpoint-path', type=str, default= "./checkpoints/model_fm_transfer.pth.tar")
parser.add_argument('--transfer-path', type=str, default= "./checkpoints/model_transfer.pth.tar")
parser.add_argument('--best-path', type= str, default= "./checkpoints/model_barlow_best.pth.tar")
parser.add_argument('--batch-size', type=int, default= 64)
parser.add_argument('--num-epochs', type=int, default= 10)
parser.add_argument('--num-steps', type=int, default= 10)
parser.add_argument('--train-from-start', type= int, default= 1)
parser.add_argument('--dataset-folder', type= str, default= "./dataset")
parser.add_argument('--new-dataset-folder', type= str, default= "./dataset")
parser.add_argument('--learning-rate', type = float, default= 0.01)
parser.add_argument('--threshold', type = float, default= 0.5)
parser.add_argument('--mu', type= int, default= 7)
parser.add_argument('--lambd', type= int, default= 1)
parser.add_argument('--momentum', type= float, default= 0.9)
parser.add_argument('--weight-decay', type= float, default= 0.001)
parser.add_argument('--layers', type= int, default= 18)
parser.add_argument('--fine-tune', type= int, default= 1)
parser.add_argument('--new-data', type= int, default= 0)
args = parser.parse_args()
dataset_folder = args.dataset_folder
batch_size_labeled = args.batch_size
mu = args.mu
batch_size_unlabeled = mu * args.batch_size
batch_size_val = 256 #5120
n_epochs = args.num_epochs
n_steps = args.num_steps
num_classes = 800
threshold = args.threshold
learning_rate = args.learning_rate
momentum = args.momentum
lamd = args.lambd
tau = 0.95
weight_decay = args.weight_decay
checkpoint_path = args.checkpoint_path
train_from_start = args.train_from_start
n_layers = args.layers
if torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
# print("pwd: ", os.getcwd())
train_transform, val_transform = get_transforms()
if args.new_data == 0:
labeled_train_dataset = CustomDataset(root= args.dataset_folder, split = "train", transform = train_transform)
else:
labeled_train_dataset = CustomDataset(root= args.new_dataset_folder, split = "train_new", transform = train_transform)
# labeled_train_dataset = CustomDataset(root= dataset_folder, split = "train", transform = train_transform)
unlabeled_train_dataset = CustomDataset(root= dataset_folder,
split = "unlabeled",
transform = TransformFixMatch(mean = 0, std = 0))#TODO
val_dataset = CustomDataset(root= dataset_folder, split = "val", transform = val_transform)
labeled_train_loader = DataLoader(labeled_train_dataset, batch_size= batch_size_labeled, shuffle= True, num_workers= 4)
unlabeled_train_loader = DataLoader(unlabeled_train_dataset, batch_size= batch_size_unlabeled, shuffle= True, num_workers= 4)
val_loader = DataLoader(val_dataset, batch_size= batch_size_val, shuffle= False, num_workers= 4)
labeled_iter = iter(labeled_train_loader)
unlabeled_iter = iter(unlabeled_train_loader)
model = wide_resnet50_2(pretrained=False, num_classes = 800)
classifier = Classifier(ip= 2048, dp = 0)
start_epoch = 0
checkpoint = torch.load(args.transfer_path, map_location= device)
model.load_state_dict(checkpoint['model_state_dict'])
classifier.load_state_dict(checkpoint['classifier_state_dict'])
param_groups = [dict(params=classifier.parameters(), lr=args.learning_rate)]
if args.fine_tune:
param_groups.append(dict(params=model.parameters(), lr=args.learning_rate))
optimizer = torch.optim.SGD(param_groups,
lr = learning_rate,
momentum= momentum,
nesterov= True,
weight_decay= weight_decay)
scheduler = get_cosine_schedule_with_warmup(optimizer, 0, num_training_steps= n_epochs * n_steps)
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
model = torch.nn.DataParallel(model)
classifier = torch.nn.DataParallel(classifier)
if train_from_start == 0:
assert os.path.isfile(checkpoint_path), "Error: no checkpoint directory found!"
print("Restoring model from checkpoint")
# args.out = os.path.dirname(args.resume)
checkpoint = torch.load(checkpoint_path)
# best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch'] - 1
model.load_state_dict(checkpoint['backbone_state_dict'])
classifier.load_state_dict(checkpoint['classifier_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
scheduler.load_state_dict(checkpoint['scheduler'])
model = model.to(device)
classifier = classifier.to(device)
model.train()
losses = Average()
losses_l = Average()
losses_u = Average()
mask_probs = Average()
best_val_accuracy = 25.0 #TODO
for epoch in tqdm(range(start_epoch, n_epochs)):
if args.fine_tune:
model.train()
classifier.train()
else:
model.eval()
classifier.train()
for batch_idx in tqdm(range(n_steps)):
try:
img_lab, targets_lab = labeled_iter.next()
except:
labeled_iter = iter(labeled_train_loader)
img_lab, targets_lab = labeled_iter.next()
try:
unlab, _ = unlabeled_iter.next()
img_weak = unlab[0]
img_strong = unlab[1]
except:
unlabeled_iter = iter(unlabeled_train_loader)
unlab, _ = unlabeled_iter.next()
img_weak = unlab[0]
img_strong = unlab[1]
img_lab = img_lab.to(device)
targets_lab = targets_lab.to(device)
img_weak = img_weak.to(device)
img_strong = img_strong.to(device)
img_cat = torch.cat((img_lab, img_weak, img_strong), dim = 0)
logits_cat = classifier(model(img_cat))
logits_lab = logits_cat[:batch_size_labeled]
# print(logits_lab.size())
logits_unlab = logits_cat[batch_size_labeled:]
# print(logits_unlab)
logits_weak, logits_strong = torch.chunk(logits_unlab, chunks= 2, dim = 0)
pseudo_label = torch.softmax(logits_weak.detach()/tau, dim= 1)
max_probs, targets_unlab = torch.max(pseudo_label, dim= 1)
mask = max_probs.ge(threshold).float()
loss_labeled = F.cross_entropy(logits_lab, targets_lab, reduction='mean')
# print("CE: ", F.cross_entropy(logits_strong, targets_unlab, reduction= 'none').size())
loss_unlabeled = (F.cross_entropy(logits_strong, targets_unlab, reduction= 'none') * mask).mean()
# print("Loss labelled, loss unlabelled: ", loss_labeled, loss_unlabeled)
loss_total = loss_labeled + lamd * loss_unlabeled
# print("Total loss: ", loss_total)
# loss_epoch += loss_total
# loss_lab_epoch += loss_labeled
# loss_unlab_epoch += loss_unlabeled
losses.update(loss_total.item())
losses_l.update(loss_labeled.item())
losses_u.update(loss_unlabeled.item())
mask_probs.update(mask.mean().item())
optimizer.zero_grad()
loss_total.backward()
optimizer.step()
scheduler.step()
# break
if batch_idx % 25 == 0:
print(f"Epoch number: {epoch}, loss: {losses.avg}, loss lab: {losses_l.avg}, loss unlab: {losses_u.avg}, mask: {mask_probs.avg}, loss_here: {loss_total.item()}, best accuracy: {best_val_accuracy:.2f}", flush= True)
# print(optimizer.param_groups[0]['lr'])
save_checkpoint({
'epoch': epoch + 1,
'model_state_dict': model.state_dict(),
'classifier_state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
}, checkpoint_path)
model.eval()
classifier.eval()
with torch.no_grad():
val_loss = 0
val_size = 0
total = 0
correct = 0
for batch in val_loader:
logits_val = classifier(model(batch[0].to(device)))
labels = batch[1].to(device)
val_loss += F.cross_entropy(logits_val, labels)
_, predicted = torch.max(logits_val.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
val_size += 1
# break
print(f"Val loss: {val_loss/val_size}, Accuracy: {(100 * correct / total):.2f}%", flush= True)
if 100 * correct / total > best_val_accuracy:
best_val_accuracy = 100 * correct / total
best_val_loss = val_loss/val_size
print(f"Saving the best model with {best_val_accuracy:.2f}% accuracy and {best_val_loss:.2f} loss", flush= True)
save_checkpoint({
'epoch': epoch + 1,
'model_state_dict': model.state_dict(),
'classifier_state_dict': classifier.state_dict(),
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
'best_val_accuracy': best_val_accuracy,
'best_val_loss': best_val_loss
}, args.best_path)
model.train()
classifier.train()
def main(args):
args = parse_args(args)
# load config
with open(args.config) as f:
cfg = yaml.safe_load(f)
wandb.init(project=cfg["wandb_project"], config=cfg, name=cfg["exp_name"])
exp_name = Path(f"exp/{cfg['exp_name']}")
# if debug is true, enable to overwrite experiment
if exp_name.exists():
logging.warning(f"{exp_name} is already exist.")
if args.debugmode:
logging.warning("Note that experiment will be overwrite.")
else:
logging.info(
"Experiment is interrupted. Make sure exp_name will be unique."
)
sys.exit(0)
exp_name.mkdir(exist_ok=True)
Path(exp_name / "model").mkdir(exist_ok=True)
Path(exp_name / "predictions").mkdir(exist_ok=True)
Path(exp_name / "log").mkdir(exist_ok=True)
Path(exp_name / "score").mkdir(exist_ok=True)
# save config
shutil.copy(args.config, (exp_name / "config.yaml"))
train_synth_df = pd.read_csv(cfg["synth_meta"], header=0, sep="\t")
train_weak_df = pd.read_csv(cfg["weak_meta"], header=0, sep="\t")
train_unlabel_df = pd.read_csv(cfg["unlabel_meta"], header=0, sep="\t")
valid_df = pd.read_csv(cfg["valid_meta"], header=0, sep="\t")
n_frames = math.ceil(cfg["max_len_seconds"] *
cfg["feature"]["sample_rate"] /
cfg["feature"]["mel_spec"]["hop_size"])
classes = valid_df.event_label.dropna().sort_values().unique()
many_hot_encoder = ManyHotEncoder(labels=classes, n_frames=n_frames)
encode_function = many_hot_encoder.encode_strong_df
# Put train_synth in frames so many_hot_encoder can work.
# Not doing it for valid, because not using labels (when prediction) and event based metric expect sec.
train_synth_df.onset = (train_synth_df.onset *
cfg["feature"]["sample_rate"] //
cfg["feature"]["mel_spec"]["hop_size"])
train_synth_df.offset = (train_synth_df.offset *
cfg["feature"]["sample_rate"] //
cfg["feature"]["mel_spec"]["hop_size"])
# For calculate validation loss. Note that do not use for calculate evaluation metrics
valid_df.onset = valid_df.onset * cfg["feature"]["sample_rate"] // cfg[
"feature"]["mel_spec"]["hop_size"]
valid_df.offset = valid_df.offset * cfg["feature"]["sample_rate"] // cfg[
"feature"]["mel_spec"]["hop_size"]
feat_dir = Path(
f"data/feat/sr{cfg['feature']['sample_rate']}_n_mels{cfg['feature']['mel_spec']['n_mels']}_"
+
f"n_fft{cfg['feature']['mel_spec']['n_fft']}_hop_size{cfg['feature']['mel_spec']['hop_size']}"
)
# collect dataset stats
if Path(f"exp/{cfg['exp_name']}/stats.npz").exists():
stats = np.load(f"exp/{cfg['exp_name']}/stats.npz", )
else:
kwargs_dataset = {
"encode_function": encode_function,
"transforms": Compose([ApplyLog()]),
}
train_synth_dataset = SEDDataset(train_synth_df,
data_dir=(feat_dir /
"train/synthetic20"),
**kwargs_dataset)
train_weak_dataset = SEDDataset(train_weak_df,
data_dir=(feat_dir / "train/weak"),
**kwargs_dataset)
train_unlabel_dataset = SEDDataset(
train_unlabel_df,
data_dir=(feat_dir / "train/unlabel_in_domain"),
**kwargs_dataset)
stats = collect_stats(
[train_synth_dataset, train_weak_dataset, train_unlabel_dataset],
f"exp/{cfg['exp_name']}/stats.npz",
)
norm_dict_params = {
"mean": stats["mean"],
"std": stats["std"],
"mode": cfg["norm_mode"],
}
train_transforms = get_transforms(
cfg["data_aug"],
nb_frames=n_frames,
norm_dict_params=norm_dict_params,
training=True,
prob=cfg["apply_prob"],
)
test_transforms = get_transforms(
cfg["data_aug"],
nb_frames=n_frames,
norm_dict_params=norm_dict_params,
training=False,
prob=0.0,
)
kwargs_dataset = {
"encode_function": encode_function,
"twice_data": True,
}
train_synth_dataset = SEDDataset(
train_synth_df,
data_dir=(feat_dir / "train/synthetic20"),
encode_function=encode_function,
pooling_time_ratio=cfg["pooling_time_ratio"],
transforms=train_transforms,
twice_data=True,
)
train_weak_dataset = SEDDataset(
train_weak_df,
data_dir=(feat_dir / "train/weak"),
encode_function=encode_function,
pooling_time_ratio=cfg["pooling_time_ratio"],
transforms=train_transforms,
twice_data=True,
)
train_unlabel_dataset = SEDDataset(
train_unlabel_df,
data_dir=(feat_dir / "train/unlabel_in_domain"),
encode_function=encode_function,
pooling_time_ratio=cfg["pooling_time_ratio"],
transforms=train_transforms,
twice_data=True,
)
valid_dataset = SEDDataset(
valid_df,
data_dir=(feat_dir / "validation"),
encode_function=encode_function,
pooling_time_ratio=cfg["pooling_time_ratio"],
transforms=test_transforms,
)
if cfg["ngpu"] > 1:
cfg["batch_size"] *= cfg["ngpu"]
train_synth_loader = DataLoader(
train_synth_dataset,
batch_size=cfg["batch_size"],
shuffle=True,
num_workers=cfg["num_workers"],
drop_last=True,
pin_memory=True,
)
train_weak_loader = DataLoader(
train_weak_dataset,
batch_size=cfg["batch_size"],
shuffle=True,
num_workers=cfg["num_workers"],
drop_last=True,
pin_memory=True,
)
train_unlabel_loader = DataLoader(
train_unlabel_dataset,
batch_size=cfg["batch_size"] * 2,
shuffle=True,
num_workers=cfg["num_workers"],
drop_last=True,
pin_memory=True,
)
valid_loader = DataLoader(
valid_dataset,
batch_size=cfg["batch_size"],
shuffle=False,
num_workers=cfg["num_workers"],
pin_memory=True,
)
# logging info
if args.verbose > 0:
logging.basicConfig(
level=logging.INFO,
format=
"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
else:
logging.basicConfig(
level=logging.WARN,
format=
"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
logging.warning("Skip DEBUG/INFO messages")
# display PYTHONPATH
logging.info("python path = " + os.environ.get("PYTHONPATH", "(None)"))
seed_everything(cfg["seed"])
model = SEDModel(n_class=len(classes),
cnn_kwargs=cfg["model"]["cnn"],
encoder_kwargs=cfg["model"]["encoder"])
ema_model = SEDModel(n_class=len(classes),
cnn_kwargs=cfg["model"]["cnn"],
encoder_kwargs=cfg["model"]["encoder"])
# Show network architecture details
logging.info(model)
logging.info(model.parameters())
logging.info(
f"model parameter: {sum(p.numel() for p in model.parameters() if p.requires_grad)}"
)
wandb.watch(model)
trainer_options = MeanTeacherTrainerOptions(**cfg["trainer_options"])
trainer_options._set_validation_options(
valid_meta=cfg["valid_meta"],
valid_audio_dir=cfg["valid_audio_dir"],
max_len_seconds=cfg["max_len_seconds"],
sample_rate=cfg["feature"]["sample_rate"],
hop_size=cfg["feature"]["mel_spec"]["hop_size"],
pooling_time_ratio=cfg["pooling_time_ratio"],
)
# set optimizer and lr scheduler
trainable_params = filter(lambda p: p.requires_grad, model.parameters())
if cfg["optimizer"] == "Adam":
optimizer = torch.optim.Adam(trainable_params,
**cfg["optimizer_params"])
else:
import torch_optimizer as optim
optimizer = getattr(optim, cfg["optimizer"])(trainable_params,
**cfg["optimizer_params"])
scheduler = getattr(torch.optim.lr_scheduler,
cfg["scheduler"])(optimizer, **cfg["scheduler_params"])
trainer = MeanTeacherTrainer(
model=model,
ema_model=ema_model,
strong_loader=train_synth_loader,
weak_loader=train_weak_loader,
unlabel_loader=train_unlabel_loader,
valid_loader=valid_loader,
optimizer=optimizer,
scheduler=scheduler,
exp_name=exp_name,
pretrained=cfg["pretrained"],
resume=cfg["resume"],
trainer_options=trainer_options,
)
trainer.run()
def main(opt):
wandb.init(project="training_loop_tutorial", entity='samiksha')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
os.makedirs("output", exist_ok=True)
os.makedirs("checkpoints", exist_ok=True)
# Initiate model
model = Darknet(opt.model_def).to(device)
model.apply(utils.weights_init_normal)
pretrained_weights = opt.pretrained_weights
if pretrained_weights is not None:
print(f'\nLoading weights: {pretrained_weights}\n')
if pretrained_weights.endswith(".pth"):
# Load our pytorch training's checkpoint
checkpoint = torch.load(pretrained_weights)
model.load_state_dict(checkpoint['model_state_dict'])
else:
# Load original author's darknet weights (trained on yolo)
model.load_darknet_weights(pretrained_weights)
# dataloader
root_train = opt.root_train
root_test = opt.root_test
img_size = opt.img_size
# dataset_train = PascalVOC(root_train, transform=get_transforms(img_size=img_size))
# dataset_test = PascalVOC(root_test, transform=get_transforms(img_size=img_size))
dataset_train = NipponDataset(root_train,
transform=get_transforms(img_size=img_size))
dataset_test = NipponDataset(root_test,
transform=get_transforms(img_size=img_size))
# Take subset of dataset for faster testing
debug_mode = opt.debug_mode
if debug_mode:
num_debug_imgs = 100
num_images_train = min(num_debug_imgs, len(dataset_train))
num_images_test = min(num_debug_imgs, len(dataset_train))
print(
f'Warning: Debugging mode, only {num_images_train} images from datasets will be used.'
)
else:
num_images_train = len(dataset_train)
num_images_test = len(dataset_test)
dataset_train = torch.utils.data.Subset(dataset_train,
list(range(num_images_train)))
dataset_test = torch.utils.data.Subset(dataset_test,
list(range(num_images_test)))
batch_size = model.hyperparams['batch']
n_cpu = opt.n_cpu
trainloader = torch.utils.data.DataLoader(dataset_train,
batch_size=batch_size,
shuffle=True,
collate_fn=collate_fn,
num_workers=n_cpu)
sampler = torch.utils.data.SequentialSampler(dataset_test)
testloader = torch.utils.data.DataLoader(dataset_test,
batch_size=batch_size,
shuffle=False,
collate_fn=collate_fn,
num_workers=n_cpu)
# optimizer
optimizer = torch.optim.Adam(
model.parameters(),
lr=model.hyperparams['learning_rate'],
weight_decay=model.hyperparams['decay'],
)
epochs = opt.epochs
evaluation_interval = opt.evaluation_interval
checkpoint_interval = opt.checkpoint_interval
log_image_interval = opt.log_image_interval
for epoch_idx in range(epochs):
print(f"Epoch {epoch_idx + 1}\n-------------------------------")
train_loop(trainloader, model, optimizer, device)
# Run Evaluation
if (epoch_idx + 1) % evaluation_interval == 0:
evaluate_metrics(model,
testloader,
device,
iou_thres=0.5,
conf_thres=0.1,
nms_thres=0.5,
mode="Test")
if (epoch_idx + 1) % log_image_interval == 0:
log_bbox_predictions(model,
testloader,
device,
conf_thres=0.5,
nms_thres=0.5,
mode="Test",
max_images_to_upload=16)
# Save checkpoint
if (epoch_idx + 1) % checkpoint_interval == 0:
run_id = wandb.run.id
save_dir = Path(f"checkpoints/{run_id}")
save_dir.mkdir(parents=True, exist_ok=True)
checkpoint_path = str(save_dir / f"yolov3_ckpt_{epoch_idx}.pth")
torch.save(
{
'epoch': epoch_idx,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
}, checkpoint_path)
def run(config_file, fold=0, device_id=0):
os.environ['CUDA_VISIBLE_DEVICES'] = str(device_id)
config = load_config(config_file)
if not '_fold' in config.work_dir:
config.work_dir = config.work_dir + '_fold{}'.format(fold)
validloader = make_loader(
data_dir=config.data.train_dir,
df_path=config.data.train_df_path,
features=config.data.features,
phase='valid',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
idx_fold=fold,
transforms=get_transforms(config.transforms.test),
model_scale=config.data.model_scale,
return_fnames=True,
)
# load model
checkpoint_path = config.work_dir + '/checkpoints/best.pth'
model = load_model(config_file, checkpoint_path)
folds = pd.read_csv('data/folds.csv')
predictions = []
targets = []
image_ids = []
z_pos = config.data.z_pos[0]
with torch.no_grad():
for i, (batch_images, batch_mask_regr,
batch_image_ids) in enumerate(tqdm(validloader)):
batch_preds = model(batch_images.to(config.device))
batch_preds[:, 0] = torch.sigmoid(batch_preds[:, 0])
batch_preds[:, z_pos] = depth_transform(batch_preds[:, z_pos])
batch_preds = batch_preds.data.cpu().numpy()
batch_mask_regr = batch_mask_regr.data.cpu().numpy()
image_ids.extend(batch_image_ids)
for preds, mask_regr, image_id in zip(batch_preds, batch_mask_regr,
batch_image_ids):
coords = extract_coords(
preds,
features=config.data.features,
img_size=(config.data.height, config.data.width),
confidence_threshold=config.test.confidence_threshold,
distance_threshold=config.test.distance_threshold,
)
predictions.append(coords)
s = folds.loc[folds.ImageId == image_id.split('.jpg')[0],
'PredictionString'].values[0]
true_coords = str2coords(
s, names=['id', 'yaw', 'pitch', 'roll', 'x', 'y', 'z'])
targets.append(true_coords)
with open(config.work_dir + '/predictions.pkl', 'wb') as f:
pickle.dump(predictions, f)
with open(config.work_dir + '/targets.pkl', 'wb') as f:
pickle.dump(targets, f)
rows = []
for p, i in zip(predictions, image_ids):
rows.append({'ImageId': i, 'PredictionString': coords2str(p)})
pred_df = pd.DataFrame(rows)
pred_df.to_csv(config.work_dir + '/val_pred.csv', index=False)
all_result, result = calc_map_score(targets, predictions)
result['confidence_threshold'] = config.test.confidence_threshold
result['distance_threshold'] = config.test.distance_threshold
dict_to_json(
all_result, config.work_dir +
'/all_result_th{}.json'.format(config.test.distance_threshold))
dict_to_json(
result, config.work_dir +
'/result_th{}.json'.format(config.test.distance_threshold))
for k in sorted(result.keys()):
print(k, result[k])
def run_seg(config_file_seg):
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# ------------------------------------------------------------------------------------------------------------
# 2. segmentation inference
# ------------------------------------------------------------------------------------------------------------
config = load_config(config_file_seg)
if 'COLAB_GPU' in os.environ:
config.work_dir = '/content/drive/My Drive/kaggle_cloud/' + config.work_dir
elif 'KAGGLE_WORKING_DIR' in os.environ:
config.work_dir = '/kaggle/working/' + config.work_dir
if os.path.exists('cls_preds.csv'):
testloader = make_loader(
data_folder=config.data.test_dir,
df_path='cls_preds.csv',
phase='filtered_test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
else:
testloader = make_loader(
data_folder=config.data.test_dir,
df_path=config.data.sample_submission_path,
phase='test',
img_size=(config.data.height, config.data.width),
batch_size=config.test.batch_size,
num_workers=config.num_workers,
transforms=get_transforms(config.transforms.test))
model = load_model(config_file_seg)
if os.path.exists(config.work_dir + '/threshold_search.json'):
with open(config.work_dir + '/threshold_search.json') as json_file:
data = json.load(json_file)
df = pd.DataFrame(data)
min_sizes = list(df.T.idxmax().values.astype(int))
print('load best threshold from validation:', min_sizes)
else:
min_sizes = config.test.min_size
print('load default threshold:', min_sizes)
predictions = []
with torch.no_grad():
for i, (batch_fnames, batch_images) in enumerate(tqdm(testloader)):
batch_images = batch_images.to(config.device)
batch_preds = predict_batch(model,
batch_images,
tta=config.test.tta)
for fname, preds in zip(batch_fnames, batch_preds):
for cls in range(preds.shape[0]):
pred, _ = post_process(
preds[cls, :, :],
config.test.best_threshold,
min_sizes[cls],
height=config.transforms.test.Resize.height,
width=config.transforms.test.Resize.width)
pred = cv2.resize(pred, (SUB_WIDTH, SUB_HEIGHT))
pred = (pred > 0.5).astype(int)
rle = mask2rle(pred)
cls_name = INV_CLASSES[cls]
name = fname + f"_{cls_name}"
predictions.append([name, rle])
# ------------------------------------------------------------------------------------------------------------
# submission
# ------------------------------------------------------------------------------------------------------------
df = pd.DataFrame(predictions, columns=['Image_Label', 'EncodedPixels'])
df.to_csv(config.work_dir + "/submission.csv", index=False)
# %%
from dataset import PombeDataset
import transforms
from matplotlib import pyplot as plt
import matplotlib.patches as patches
import numpy as np
root = '/home/cjw/Code/xlearn/Data'
image_dir = 'Ibig'
mask_dir = 'Mbig'
t = transforms.get_transforms()
p = PombeDataset(root, image_dir, mask_dir, t)
v = p.__getitem__(3)
# %%
vn = v[0].numpy()
print(vn.shape)
vn = np.moveaxis(v[0].numpy(), 0, -1)
# %%
fig, ax = plt.subplots(1)
ax.imshow(vn[:, :, 0])
for b in v[1]['boxes']:
print(b)
rx, ry, rxf, ryf = b
w = rxf - rx
h = ryf - ry
rp = patches.Rectangle((rx, ry), w, h, edgecolor='r', facecolor='none')
ax.add_patch(rp)
parser.add_argument("--batch_size", type=int, default=8, help="batch size")
opt = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
# Setup model
model = Darknet(opt.model_def, img_size=416).to(device)
# Load weights
if opt.weights_path is not None:
if opt.weights_path.endswith('.weights'):
# Load original author's darknet weights
print('Loading darknet weights')
model.load_darknet_weights(opt.weights_path)
else:
# Load our training checkpoint weights
print('Loading trained checkpoint')
checkpoint = torch.load(opt.weights_path, map_location=device)
model.load_state_dict(checkpoint['model_state_dict'])
# dataloader
root_test = opt.root_test
dataset_test = NipponDataset(root_test, transform=get_transforms(img_size=416))
conf_thres = opt.conf_thres
nms_thres = opt.nms_thres
batch_size = opt.batch_size
# Should this be changed ???
testloader = torch.utils.data.DataLoader(dataset_test, batch_size=batch_size, shuffle=False, num_workers=1)
inference_visualize(model, testloader, device, conf_thres=conf_thres, nms_thres=nms_thres)
