コード例 #1
0
def init():
    parser = argparse.ArgumentParser()
    parser.add_argument('--config_path', default=None, type=str, help='配置文件路径')
    args, _ = parser.parse_known_args()

    cfg.merge_from_file(args.config_path)
    utils.mkdir(cfg.test.output_dir)
コード例 #2
0
ファイル: base.py プロジェクト: devpouya/dep-parser
 def save(self, path):
     utils.mkdir(path)
     fname = self.get_name(path)
     torch.save({
         'kwargs': self.get_args(),
         'model_state_dict': self.state_dict(),
     }, fname)
コード例 #3
0
ファイル: train.py プロジェクト: lzr9926/speech-recognition
def main(unused_argv):
    if FLAGS.config is None:
        raise Exception("Config file must be provided")

    json_file = open('model_configs/%s.json' % FLAGS.config).read()
    json_dict = json.loads(json_file)
    BatchedInput = utils.get_batched_input_class(
        json_dict.get("input", "default"))
    Model = utils.get_model_class(json_dict.get("model"))

    hparams = utils.create_hparams(FLAGS, Model)
    hparams.hcopy_path = configs.HCOPY_PATH
    hparams.hcopy_config = os.path.join(configs.HCOPY_CONFIG_PATH)

    # create directories for logs and saved parameters
    utils.mkdir(hparams.summaries_dir)
    utils.mkdir(hparams.out_dir)
    utils.clear_log(hparams)

    random_seed = FLAGS.random_seed
    if random_seed is not None and random_seed > 0:
        random.seed(random_seed)
        np.random.seed(random_seed)

    train(Model, BatchedInput, hparams)
コード例 #4
0
ファイル: logger.py プロジェクト: DHZS/faster-rcnn-pytorch
 def __init__(self,
              folder,
              file_name=None,
              append=None,
              time_format=None,
              use_pprint=False):
     utils.mkdir(folder.strip())
     self.folder = folder.strip()
     if file_name and file_name.strip()[-1] == '+':
         self.file_name = file_name.strip()[:-1]
         self.append = False if append is False else True
     else:
         self.file_name = None
         self.append = bool(append)
     self.time_format = time_format or '%Y%m%d_%H%M%S.log'
     self.path = None
     self.file = None
     self.init = True
     if use_pprint:
         from pprint import pprint
         self.print_fn = lambda text, stream=sys.stdout: print(text, file=stream) \
             if isinstance(text, str) else pprint(text, stream, width=200)
     else:
         self.print_fn = lambda text, stream=sys.stdout: print(text,
                                                               file=stream)
コード例 #5
0
def create_sample_set(data_dir):
    """Create a sample set of the training data for quick experimentation"""

    train_dir = os.path.join(data_dir, 'train')
    driver_data = get_driver_data(data_dir)
    sample_set = set({
        img
        for (img, dr_id) in driver_data.items()
        if dr_id in DRIVER_IDS_TRAIN[:2]
    })
    valid_set = set({
        img
        for (img, dr_id) in driver_data.items()
        if dr_id in DRIVER_IDS_TRAIN[2:3]
    })

    train_files = glob(train_dir + '/c?/*.jpg')
    sample_files = [
        f for f in train_files if os.path.basename(f) in sample_set
    ]
    valid_files = [f for f in train_files if os.path.basename(f) in valid_set]

    for train_path in sample_files:
        target_path = get_sample_path(train_path)
        mkdir(os.path.dirname(target_path))
        copyfile(train_path, target_path)

    for train_path in valid_files:
        target_path = get_valid_path(get_sample_path(train_path))
        mkdir(os.path.dirname(target_path))
        copyfile(train_path, target_path)
コード例 #6
0
ファイル: dogbreed.py プロジェクト: gabesoft/fast-ai
def setup_train_data(data_dir):
    labels_file = join(data_dir, 'labels.csv')
    df_train = pd.read_csv(labels_file)
    df_grouped = df_train.groupby('breed').aggregate(lambda x: list(x))

    for breed in df_grouped.index:
        ids = df_grouped.id[breed]
        breed_len = len(ids)
        breed_len_train = np.ceil(breed_len * TRAIN_AMT).astype('int')

        train_ids = ids[:breed_len_train]
        valid_ids = ids[breed_len_train:]

        train_dir = join(data_dir, 'train')
        target_train_dir = join(train_dir, breed)
        target_valid_dir = join(data_dir, 'valid', breed)

        mkdir(target_train_dir)
        mkdir(target_valid_dir)

        for tid in train_ids:
            fpath = '%s.jpg' % tid
            src_path = join(train_dir, fpath)
            dst_path = join(target_train_dir, fpath)
            os.rename(src_path, dst_path)

        for vid in valid_ids:
            fpath = '%s.jpg' % vid
            src_path = join(train_dir, fpath)
            dst_path = join(target_valid_dir, fpath)
            os.rename(src_path, dst_path)
コード例 #7
0
 def __init__(self,
              image_set,
              path,
              use_difficult=False,
              name=None,
              training=True):
     super(PascalVoc, self).__init__()
     self.training = training  # super
     assert image_set in ('train', 'trainval', 'val', 'test')
     self.image_set = image_set
     self.use_difficult = use_difficult
     self.name = (name or 'pascal_voc') + '_' + self.image_set + \
                 ('_no_hard', '_use_hard')[self.use_difficult] + \
                 (('_no_flip', '_use_flip')[cfg.flip] if self.training else '')  # super
     self.path = path
     self.image_path = os.path.join(self.path, 'JPEGImages', '{}.jpg')
     self.xml_path = os.path.join(self.path, 'Annotations', '{}.xml')
     utils.mkdir(cfg.cache_path)
     self.cache_path = os.path.join(
         cfg.cache_path, '{}_annotations.pkl'.format(self.name))  # super
     self.image_set_path = ''
     self.num_class = len(CLASSES)
     self.class_to_index = dict(zip(CLASSES, range(
         self.num_class)))  # {'cls': id, ...}
     self.image_ids = self._load_image_id()  # super
     self.all_annotations = None  # super
コード例 #8
0
    def _export_tabular_model(self, domain_id, task_id):
        domain_folder = self.get_models_folder(domain_id)
        utils.mkdir(domain_folder)

        model_path = self._get_tabular_model_path(domain_folder, task_id)
        q_table = self._get_q_function(domain_id, task_id)
        np.save(model_path, q_table)
コード例 #9
0
    def extract_audio(self, args):
        if (len(args) != 2):
            self.raise_err("extract_audio")
            return

        src_dir, to_dir = args
        print('>>> Extract Audio. <<<\n')
        # walk src_dir, do 'Extract Audio'.
        for root, subdirs, files in os.walk(src_dir):
            if not subdirs:
                print('Extract Audio: {}'.format(root))
                pid = root.split('/video/mpg_6000')[0]
                pid = pid.split('/')[-1]
                for f in files:
                    if (not (f.endswith('.mp4') or f.endswith('.mpg'))):
                        continue
                    # s2/lgbm3p.mpg
                    movie_id = f.split('.')[0]

                    src_movie_file = os.path.join(root, f)
                    to_extract_dir = os.path.join(to_dir, pid, movie_id)
                    utils.mkdir(to_extract_dir)
                    if (os.path.exists(
                            os.path.join(to_extract_dir, 'audio.wav'))):
                        continue
                    cmd = 'ffmpeg -i {} -vn {}'.format(
                        src_movie_file,
                        os.path.join(to_extract_dir, 'audio.wav'))
                    proc = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)
                    try:
                        buff = proc.communicate()
                    except Exception as e:
                        print('Extract Audio FAILED.\n')
                        sys.exit(1)
                        proc.stdout.close()
コード例 #10
0
ファイル: option_parser.py プロジェクト: codealphago/GibbsNet
    def parse_args(self):
        opt = self.parser.parse_args()
        str_ids = str(opt.gpu_ids)
        opt.gpu_ids = []
        for str_id in str_ids.split(','):
            opt.gpu_ids.append(int(str_id))
        if len(opt.gpu_ids) > 0:
            torch.cuda.set_device(opt.gpu_ids[0])

        args = vars(opt)

        print('-------- [INFO] Options --------')
        for k, v in sorted(args.items()):
            print('%s: %s' % (str(k), str(v)))

        expr_dir = os.path.join(opt.ckpt_dir, opt.model)
        utils.mkdir(expr_dir)
        test_dir = os.path.join(opt.test_dir, opt.model)
        utils.mkdir(test_dir)
        file_name = os.path.join(expr_dir, 'opt.txt')
        with open(file_name, 'wt') as opt_file:
            opt_file.write(' [INFO] Options\n')
            for k, v in sorted(args.items()):
                opt_file.write('%s: %s\n' % (str(k), str(v)))
        print('------------- END -------------')
        return opt
コード例 #11
0
    def parse_args(self):
        opt = self.parser.parse_args()
        str_ids = str(opt.gpu_ids)
        opt.gpu_ids = []
        for str_id in str_ids.split(','):
            opt.gpu_ids.append(int(str_id))
        if len(opt.gpu_ids) > 0:
            torch.cuda.set_device(opt.gpu_ids[0])

        args = vars(opt)

        print('-------- [INFO] Options --------')
        for k, v in sorted(args.items()):
            print('%s: %s' % (str(k), str(v)))

        expr_dir = os.path.join(opt.ckpt_dir, opt.model)
        utils.mkdir(expr_dir)
        test_dir = os.path.join(opt.test_dir, opt.model)
        utils.mkdir(test_dir)
        file_name = os.path.join(expr_dir, 'opt.txt')
        with open(file_name, 'wt') as opt_file:
            opt_file.write(' [INFO] Options\n')
            for k, v in sorted(args.items()):
                opt_file.write('%s: %s\n' % (str(k), str(v)))
        print('------------- END -------------')
        return opt
コード例 #12
0
    def _export_dqn_model(self, domain_id, task_id, automaton, automaton_state):
        domain_folder = self.get_models_folder(domain_id)
        utils.mkdir(domain_folder)

        model_path = self._get_dqn_model_path(domain_folder, task_id, automaton_state)
        model = self._get_q_function(domain_id, task_id)[automaton.get_state_id(automaton_state)]
        torch.save(model.state_dict(), model_path)
コード例 #13
0
ファイル: test.py プロジェクト: ancy397031272/seg_pytorch
    def run(self):
        # Data loading code
        print("Loading data")
        test_dir = self.config['Dataset']['TestPath']
        pred_result_dir = os.path.join(test_dir, 'pred_result_info')
        utils.mkdir(pred_result_dir)

        dataset_test = torchvision.datasets.ImageFolder(
            test_dir, transforms.Compose([transforms.ToTensor()]))
        test_sampler = torch.utils.data.SequentialSampler(dataset_test)

        data_loader_test = torch.utils.data.DataLoader(dataset_test,
                                                       batch_size=1,
                                                       sampler=test_sampler,
                                                       num_workers=1,
                                                       pin_memory=True)

        print("Creating model")
        model = getModels(model_name=self.config['Model']['Name'],
                          num_classes=self.config['Model']['NumClass'])
        model.to(self.device)

        checkpoint = torch.load(os.path.join(
            self.output_model_path, self.config['Misc']['BestModelName']),
                                map_location='cpu')
        model.load_state_dict(checkpoint['model'])
        correct_1 = 0.0
        model.eval()
        print(dataset_test.class_to_idx)
        with torch.no_grad():
            for i, (image, label) in enumerate(data_loader_test):
                image = image.to(self.device, non_blocking=True)
                label = label.to(self.device, non_blocking=True)
                output = model(image)

                _, pred = output.topk(1, 1, largest=True, sorted=True)
                label = label.view(label.size(0), -1).expand_as(pred)

                correct = pred.eq(label)
                correct_1 += correct[:, :1].sum()

                for key in dataset_test.class_to_idx:
                    if dataset_test.class_to_idx[key] == label:
                        label_info = key
                    if dataset_test.class_to_idx[key] == pred:
                        pred_info = key

                src_img = cv2.imread(dataset_test.imgs[i][0], 1)
                cv2.putText(src_img, 'label: {}'.format(label_info), (20, 30),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 1)
                cv2.putText(src_img, 'pred: {}'.format(pred_info), (20, 60),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 20), 1)
                if label_info != pred_info:
                    shutil.move(dataset_test.imgs[i][0], pred_result_dir)
                    # cv2.imwrite(os.path.join(pred_result_dir, '{}.png'.format(i)), src_img)
                cv2.imshow('img', src_img)
                cv2.waitKey(33)

        print("acc: ", correct_1 / len(data_loader_test.dataset))
コード例 #14
0
def _get_voc_results_file_template():
    """获取检测结果文件路径模板"""
    # {output_dir}/detection_result/{dataset_name}_{image_set}_{cls_name}.txt
    path = os.path.join(cfg.test.output_dir, 'detection_result')
    utils.mkdir(path)
    file_name = '_'.join([cfg.dataset_name[0], cfg.image_set[0], '{}.txt'])
    file_path = os.path.join(path, file_name)
    return file_path
コード例 #15
0
 def initialize(self, opt, **kwargs):
     self.gpu_ids = opt.gpu_ids
     if len(self.gpu_ids) < 1:
         self.use_cuda = False
     self.isTrain = opt.isTrain
     self.ImgTensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
     self.LblTensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
     self.save_dir = opt.save_dir
     mkdir(self.save_dir)
コード例 #16
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, required=True, help="Path to the dataset directory.")
    parser.add_argument("--degree", type=int, default=5, help="Degree of the bezier curves.")
    parser.add_argument("--ckpt", type=str, required=True, help="Path to the checkpoint file.")
    parser.add_argument("--gpu_ids", type=str, default='', help="Specify the GPU ids.")
    parser.add_argument("--seed", type=int, default=0, help="Random seed.")
    parser.add_argument("--batch_size", type=int, default=256, help="Batch size.")
    parser.add_argument("--num_workers", type=int, default=4, help="Number of workers.")
    parser.add_argument("--input_size", type=int, nargs=2, required=True, help="Size of the input image (w, h).")
    parser.add_argument("--max_lane", type=int, default=4, help="Maximum number of lanes.")
    parser.add_argument("--num_points", type=int, default=72, help="Number of points sampled from each lane.")
    parser.add_argument("--feat_dim", type=int, default=384, help="The output feature dimension of the backbone.")
    parser.add_argument("--save_name", type=str, default="./video/output.avi", help="Path to save the video.")

    args = parser.parse_args()
    print(args)

    for s in args.gpu_ids:
        try:
            int(s)
        except ValueError as e:
            print("Invalid gpu id: {}".format(s))
            raise ValueError

    os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(args.gpu_ids)

    if args.gpu_ids:
        if torch.cuda.is_available():
            use_gpu = True
            cudnn.benchmark = True
            torch.cuda.manual_seed(args.seed)
        else:
            use_gpu = False
    else:
        use_gpu = False

    train_loader, val_loader, test_loader, num_fc_nodes = build_dataloader(args.data,
                                                                           args.batch_size,
                                                                           tuple(args.input_size),
                                                                           args.degree,
                                                                           args.num_points,
                                                                           args.max_lane, use_gpu,
                                                                           args.num_workers)

    model = CustomResnet(args.feat_dim, '', args.max_lane, num_fc_nodes)

    if os.path.exists(args.ckpt):
        model.load_state_dict(torch.load(args.ckpt))

    if use_gpu:
        model = model.cuda()

    folder, _ = os.path.split(args.save_name)
    mkdir(folder)

    evaluate(model, test_loader, args.degree, args.save_name, use_gpu)
コード例 #17
0
ファイル: datasetup.py プロジェクト: gabesoft/fast-ai
def create_validation_set(data_dir):
    """Create a validation set from a subset of the training files"""

    files = get_rand_train_files(data_dir)

    mkdir(data_dir + '/valid')
    for i in range(2000):
        file_name = os.path.basename(files[i])
        os.rename(files[i], data_dir + '/valid/' + file_name)
コード例 #18
0
ファイル: datasetup.py プロジェクト: gabesoft/fast-ai
def create_test_set(data_dir):
    """Create a single unknown class for the test set"""

    files = glob(data_dir + '/test/*.jpg')

    mkdir(data_dir + '/test/unknown')

    for f in files:
        os.rename(f, data_dir + '/test/unknown/' + os.path.basename(f))
コード例 #19
0
    def mxnet_sat_alignment(self, args):
        if (len(args) != 3):
            self.raise_err("mxnet SAT alignment")
            return

        src_dir, to_dir, model_dir = args

        # walk movie dir, do 'face crop' and 'pose estimate'.
        for root, subdirs, files in os.walk(src_dir):
            if not subdirs:
                pid = root.split('/video/mpg_6000')[0]
                pid = pid.split('/')[-1]
                for f in files:
                    if (not (f.endswith('.mp4') or f.endswith('.mpg'))):
                        continue

                    movie_id = f.split('.')[0]
                    src_movie_file = os.path.join(root, f)
                    to_crop_dir = os.path.join(to_dir, pid, movie_id)
                    utils.mkdir(to_crop_dir)
                    print('mxnet SAT: {}'.format(to_crop_dir))

                    if (os.path.exists(
                            os.path.join(to_crop_dir, "landmark.txt"))):
                        continue

                    labelfile = open(os.path.join(to_crop_dir, 'landmark.txt'),
                                     'w')

                    cap = cv2.VideoCapture(src_movie_file)
                    if (cap.isOpened()):
                        idx = 0
                        success, image = cap.read()
                        while (success):
                            [h, w, c] = image.shape
                            if c > 3:
                                image = image[:, :, :3]

                            lmk_results = utils.get_mxnet_sat_alignment(
                                model_dir, image)
                            if (lmk_results is None):
                                os.system('rm -rf {}'.format(to_crop_dir))
                                break
                            _, _, img_cropped, lmk_cropped, center_x, center_y, ratio = lmk_results

                            labelfile.write('{}\n'.format(','.join(
                                ['{:.2f}'.format(v) for v in lmk_cropped])))
                            cv2.imwrite(
                                os.path.join(to_crop_dir,
                                             '{}.jpg'.format(idx)),
                                img_cropped,
                                [int(cv2.IMWRITE_JPEG_QUALITY), 100])
                            idx += 1
                            success, image = cap.read()
                        labelfile.close()
                    cap.release()
コード例 #20
0
def save_model(data_dir, model):
    json_data = model.to_json()
    cache_dir = os.path.join(data_dir, 'cache')
    t = strftime('%Y-%m-%d-%H')
    architecture_file = 'architecture-%s.json' % t
    weights_file = 'model-weights-%s.json' % t

    mkdir(cache_dir)
    open(os.path.join(cache_dir, architecture_file), 'w').write(json_data)
    model.save_weights(os.path.join(cache_dir, weights_file), overwrite=True)
コード例 #21
0
    def _solve_ilasp_task(self, domain_id):
        utils.mkdir(self.get_automaton_solution_folder(domain_id))

        ilasp_task_filename = os.path.join(self.get_automaton_task_folder(domain_id),
                                           ISAAlgorithmBase.AUTOMATON_TASK_FILENAME % self.automaton_counters[domain_id])

        ilasp_solution_filename = os.path.join(self.get_automaton_solution_folder(domain_id),
                                               ISAAlgorithmBase.AUTOMATON_SOLUTION_FILENAME % self.automaton_counters[domain_id])

        return solve_ilasp_task(ilasp_task_filename, ilasp_solution_filename, timeout=self.ilasp_timeout,
                                version=self.ilasp_version, max_body_literals=self.max_body_literals,
                                binary_folder_name=self.binary_folder_name, compute_minimal=self.ilasp_compute_minimal)
コード例 #22
0
ファイル: datasetup.py プロジェクト: gabesoft/fast-ai
def create_label_dirs(parent_dir):
    cats = glob(parent_dir + '/cat.*.jpg')
    dogs = glob(parent_dir + '/dog.*.jpg')

    mkdir(parent_dir + '/cats')
    mkdir(parent_dir + '/dogs')

    for cat in cats:
        os.rename(cat, parent_dir + '/cats/' + os.path.basename(cat))

    for dog in dogs:
        os.rename(dog, parent_dir + '/dogs/' + os.path.basename(dog))
コード例 #23
0
    def save_network(self, network, network_label, iter_step):

        util.mkdir(self.opt['path']['checkpoints']['models'])
        save_filename = '{}_{}.pth'.format(iter_step, network_label)
        save_path = os.path.join(self.opt['path']['checkpoints']['models'],
                                 save_filename)

        if isinstance(network, nn.DataParallel):
            network = network.module
        state_dict = network.state_dict()
        for key, param in state_dict.items():
            state_dict[key] = param.cpu()
        torch.save(state_dict, save_path)
コード例 #24
0
def save_model(path, model, optimizer=None, scheduler=None, iteration=None):
    """保存模型"""
    folder = os.path.split(path)[0]
    utils.mkdir(folder)
    state = dict()
    state['model'] = model.state_dict()
    if optimizer is not None:
        state['optimizer'] = optimizer.state_dict()
    if scheduler is not None:
        state['scheduler'] = scheduler.state_dict()
    if iteration is not None:
        state['iteration'] = iteration
    torch.save(state, path)
コード例 #25
0
def create_validation_set(data_dir):
    """Move the validation files to a separate directory"""

    train_dir = os.path.join(data_dir, 'train')
    driver_data = get_driver_data(data_dir)
    valid_set = set({
        img
        for (img, dr_id) in driver_data.items() if dr_id in DRIVER_IDS_VALID
    })
    train_files = glob(train_dir + '/c?/*.jpg')
    valid_files = [f for f in train_files if os.path.basename(f) in valid_set]

    for train_path in valid_files:
        valid_path = get_valid_path(train_path)
        mkdir(os.path.dirname(valid_path))
        os.rename(train_path, valid_path)
コード例 #26
0
    def crop_images(self):
        # To generate crop car images.
        image_dir = os.path.join(self.root_dir, 'car_ims_cropped')
        print("Cropping Images...")
        utils.mkdir(image_dir)
        for row in tqdm(self.index_table):
            name = row[0][0]

            image = Image.open(os.path.join(self.root_dir, name))
            image = image.crop((
                row[1][0][0],
                row[2][0][0],
                row[3][0][0],
                row[4][0][0],
            ))
            image.save(os.path.join(image_dir, name.split('/')[-1]))
コード例 #27
0
ファイル: datasetup.py プロジェクト: gabesoft/fast-ai
def create_sample_set(data_dir):
    """Create a validation set from a subset of the training files"""

    files_train = get_rand_train_files(data_dir)
    files_valid = get_rand_train_files(data_dir)

    mkdir(data_dir + '/sample/train')
    mkdir(data_dir + '/sample/valid')

    for i in range(200):
        file_name = os.path.basename(files_train[i])
        copyfile(files_train[i], data_dir + '/sample/train/' + file_name)

    for i in range(50):
        file_name = os.path.basename(files_valid[i])
        copyfile(files_valid[i], data_dir + '/sample/valid/' + file_name)
コード例 #28
0
    def validate(self, val_batch, current_step):
        avg_psnr = 0.0
        avg_ssim = 0.0
        idx = 0
        for _, val_data in enumerate(val_batch):
            idx += 1
            img_name = os.path.splitext(
                os.path.basename(val_data['LR_path'][0]))[0]
            img_dir = os.path.join(
                self.opt['path']['checkpoints']['val_image_dir'], img_name)
            util.mkdir(img_dir)

            self.val_lr = val_data['LR'].to(self.device)
            self.val_hr = val_data['HR'].to(self.device)

            self.G.eval()
            with torch.no_grad():
                self.val_sr = self.G(self.val_lr)
            self.G.train()

            val_LR = self.val_lr.detach()[0].float().cpu()
            val_SR = self.val_sr.detach()[0].float().cpu()
            val_HR = self.val_hr.detach()[0].float().cpu()

            sr_img = util.tensor2img(val_SR)  # uint8
            gt_img = util.tensor2img(val_HR)  # uint8

            # Save SR images for reference
            save_img_path = os.path.join(
                img_dir, '{:s}_{:d}.png'.format(img_name, current_step))
            cv2.imwrite(save_img_path, sr_img)

            # calculate PSNR
            crop_size = 4
            gt_img = gt_img / 255.
            sr_img = sr_img / 255.
            cropped_sr_img = sr_img[crop_size:-crop_size,
                                    crop_size:-crop_size, :]
            cropped_gt_img = gt_img[crop_size:-crop_size,
                                    crop_size:-crop_size, :]
            avg_psnr += PSNR(cropped_sr_img * 255, cropped_gt_img * 255)
            avg_ssim += SSIM(cropped_sr_img * 255, cropped_gt_img * 255)

        avg_psnr = avg_psnr / idx
        avg_ssim = avg_ssim / idx
        return avg_psnr, avg_ssim
コード例 #29
0
 def save_training_state(self, epoch, iter_step):
     '''Saves training state during training, which will be used for resuming'''
     state = {
         'epoch': epoch,
         'iter': iter_step,
         'schedulers': [],
         'optimizers': []
     }
     for s in self.schedulers:
         state['schedulers'].append(s.state_dict())
     for o in self.optimizers:
         state['optimizers'].append(o.state_dict())
     save_filename = '{}.state'.format(iter_step)
     util.mkdir(self.opt['path']['checkpoints']['states'])
     save_path = os.path.join(self.opt['path']['checkpoints']['states'],
                              save_filename)
     torch.save(state, save_path)
コード例 #30
0
    def _generate_ilasp_task(self, task, domain_id):
        utils.mkdir(self.get_automaton_task_folder(domain_id))

        ilasp_task_filename = ISAAlgorithmBase.AUTOMATON_TASK_FILENAME % self.automaton_counters[domain_id]

        observables = task.get_observables()
        if self.use_restricted_observables:
            observables = task.get_restricted_observables()

        # the sets of examples are sorted to make sure that ILASP produces the same solution for the same sets (ILASP
        # can produce different hypothesis for the same set of examples but given in different order)
        generate_ilasp_task(self.num_automaton_states[domain_id], ISAAlgorithmBase.ACCEPTING_STATE_NAME,
                            ISAAlgorithmBase.REJECTING_STATE_NAME, observables, sorted(self.goal_examples[domain_id]),
                            sorted(self.dend_examples[domain_id]), sorted(self.inc_examples[domain_id]),
                            self.get_automaton_task_folder(domain_id), ilasp_task_filename, self.symmetry_breaking_method,
                            self.max_disjunction_size, self.learn_acyclic_graph, self.use_compressed_traces,
                            self.avoid_learning_only_negative, self.prioritize_optimal_solutions, self.binary_folder_name)
コード例 #31
0
    def __init__(self):
        # 加载配置文件
        self.config = utils.loadYaml('../config/config.yaml')
        # 训练结果保存路径
        self.output_model_path = os.path.join(
            '../output/', self.config['Misc']['OutputFolderName'])
        if self.config['Misc']['OutputFolderName']:
            utils.mkdir(self.output_model_path)
        else:
            raise IOError('请输入训练结果保存路径...')
        # gpu使用
        self.device = utils.set_gpu(self.config)
        self.summaryWriter = SummaryWriter(log_dir=self.output_model_path)

        # logger日志
        setup_logger(self.output_model_path)
        self.logger = get_logger()
コード例 #32
0
ファイル: apple2html.py プロジェクト: blue119/Apple2RSS
def get_one_page(utils):
    time_one_page = time()
    news_api = AppleNews(html_r(), 'http://www.appledaily.com.tw/')
    api = SaveAppleNewsToHtml(news_api.home_url)
    api.store_in = "one_page/"
    utils.mkdir(api.store_in, True)
    utils.mkdir(api.store_in + '/img', True)
    f = open(api.store_in + 'apple.html', 'w')

    PageContent = utils.GetPage(opt.page)
    PageContent = news_api.page_parser(PageContent)
    api.PastHeader(f, "")
    PageContent = api.page_compose(PageContent)
    api.PastEntry(f, "", "", ''.join(PageContent), "")
    api.PastTail(f)
    logger.info("get one page spend %d sec", time() - time_one_page)
    sys.exit()
コード例 #33
0
ファイル: apple2html.py プロジェクト: blue119/Apple2RSS
    setdefaulttimeout(timeout)

    if opt.page:
        get_one_page(utils)

    time_get_list = time()
    news_api = AppleNews(html_r(), 'http://www.appledaily.com.tw/')
    news_api.get_list('appledaily/todayapple')
    time_end_get_list = time() - time_get_list
    logger.info("get list spend %d sec", time_end_get_list)

    api = SaveAppleNewsToHtml(news_api.home_url)

    #Folder Prepare
    api.store_in = opt.folder + "/" + strftime("%Y-%m-%d", localtime())
    utils.mkdir(opt.folder, False)
    utils.mkdir(api.store_in, False)
    utils.mkdir(api.store_in + '/img', False)

    blacklist = open('blacklist.txt', 'r').readlines()
    if blacklist:
        blf = open(api.store_in + '/blacklist.html', 'w')
        api.PastHeader(blf, 'BalckList')

    for Classify in news_api.news_lists:
        if NameMap.get(Classify):
            f = open(api.store_in + "/" + NameMap.get(Classify) + '.html', 'w')
        else:
            logger.info('%s, not support' % (Classify))
            continue