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)