def get_dataloader(config): # Obtain image and label transformations according to random seeding above # Augmentation occurs when is_train flag is set to True, hence not during validation transform_img_train, transform_label_train = get_transform(config, is_train=True) transform_img_val, transform_label_val = get_transform(config, is_train=False) # Create Dataset from class defined above train_set = Dataset(config['root'] + '/train', config['size'], transform_img_train, transform_label_train) val_set = Dataset(config['root'] + '/validate', config['size'], transform_img_val, transform_label_val) # DataLoader combines dataset and sampler (if provided) as well as provides iterable over dataset train_loader = DataLoader(train_set, batch_size=config['batch_size'], shuffle=config['shuffle'], num_workers=0, drop_last=False) val_loader = DataLoader(val_set, batch_size=1, shuffle=config['shuffle'], num_workers=0, drop_last=False) return train_loader, val_loader
def __init__(self, root, split, image_size=(300, 300), keep_difficult=False): """ A PyTorch Dataset class to be used in a PyTorch DataLoader to create batches. :param root: path to stored voc data :param split: split, 'TRAIN' or 'TEST', train and val dataset from both 2007 and 2012 is used for 'TRAIN' split, test dataset from 2007 is used for 'TEST' split. :param image_size: (height, width) for network input size :param keep_difficult: keep ot discard objects considered diffcult to detect """ split = split.upper() assert split in {'TRAIN', 'TEST'} self.keep_difficult = keep_difficult self.transform = get_transform(image_size, split) if split == 'TRAIN': self.datasets = [ VOCDetection(root, year='2007', image_set='trainval'), VOCDetection(root, year='2012', image_set='trainval') ] else: self.datasets = [VOCDetection(root, year='2007', image_set='test')]
def eval(net, data_dict, ensemble_num, recalls): net.eval() data_set = ImageReader(data_dict, get_transform(DATA_NAME, 'test')) data_loader = DataLoader(data_set, BATCH_SIZE, shuffle=False, num_workers=8) features = [] with torch.no_grad(): for inputs, labels in data_loader: out = net(inputs.to(DEVICE)) out = F.normalize(out) features.append(out.cpu()) features = torch.cat(features, 0) torch.save( features, 'results/{}_test_features_{:03}.pth'.format(DATA_NAME, ensemble_num)) # load feature vectors features = [ torch.load('results/{}_test_features_{:03}.pth'.format(DATA_NAME, d)) for d in range(1, ensemble_num + 1) ] features = torch.cat(features, 1) acc_list = recall(features, data_set.labels, rank=recalls) desc = '' for index, recall_id in enumerate(recalls): desc += 'R@{}:{:.2f}% '.format(recall_id, acc_list[index] * 100) print(desc)
def test_au_interp(self, src_img_name): src_img = Image.open(os.path.join(self.data_dir, src_img_name)) transform = utils.get_transform() src_img = transform(src_img) print(src_img.shape) os.makedirs(self.test_interp_path + '/' + self.version + '/', exist_ok=True) au_interp = self.FloatTensor(np.linspace(0, 5, 6)) base_cond = self.FloatTensor(np.zeros(self.au_dim)) for d in range(self.au_dim): for i in range(len(au_interp)): test_cond = base_cond test_cond[d] = au_interp[i] test_cond = test_cond.reshape(1, self.au_dim) # print(test_cond.shape, self.g_enc(src_img, 1).shape) img_tgt = self.g_dec(self.g_enc(src_img, 1), test_cond) save_image( denorm(img_tgt.data), self.test_interp_path + '/' + self.version + '/' + str(d) + '_' + str(i) + '_' + src_img_name + '.jpg')
def __init__(self, phase='train', resize=224, csv_file=csv_file, root_dir=training_dir): """ Args: csv_file (string): Path to the csv file with annotations. root_dir (string): Directory with all the images. transform (callable, optional): Optional transform to be applied on a sample. """ self.phase = phase self.resize = (resize, resize) self.num_classes = 196 self.root_dir = training_dir if phase == 'train' else testing_dir self.name2label, _ = mapping(csv_file) self.transform = get_transform(self.resize, phase) if self.phase == 'train': self.label_frame = pd.read_csv(csv_file) self.image_path = [ os.path.join(self.root_dir, '{:06d}.jpg'.format(x)) for x in self.label_frame['id'].to_list() ] else: self.image_path = glob(self.root_dir + '/*.jpg')
def __init__(self, phase='train', resize=500): assert phase in ['train', 'val', 'test'] self.phase = phase self.resize = resize variants_dict = {} with open(os.path.join(DATAPATH, 'variants.txt'), 'r') as f: for idx, line in enumerate(f.readlines()): variants_dict[line.strip()] = idx self.num_classes = len(variants_dict) if phase == 'train': list_path = os.path.join(DATAPATH, 'images_variant_trainval.txt') else: list_path = os.path.join(DATAPATH, 'images_variant_test.txt') self.images = [] self.labels = [] with open(list_path, 'r') as f: for line in f.readlines(): fname_and_variant = line.strip() self.images.append(fname_and_variant[:FILENAME_LENGTH]) self.labels.append( variants_dict[fname_and_variant[FILENAME_LENGTH + 1:]]) # transform self.transform = get_transform(self.resize, self.phase)
def __init__(self, phase='train', resize=500): assert phase in ['train', 'val', 'test'] self.phase = phase self.resize = resize self.image_id = [] self.num_classes = 200 # get image path from images.txt with open(os.path.join(DATAPATH, 'images.txt')) as f: for line in f.readlines(): id, path = line.strip().split(' ') image_path[id] = path # get image label from image_class_labels.txt with open(os.path.join(DATAPATH, 'image_class_labels.txt')) as f: for line in f.readlines(): id, label = line.strip().split(' ') image_label[id] = int(label) # get train/test image id from train_test_split.txt with open(os.path.join(DATAPATH, 'train_test_split.txt')) as f: for line in f.readlines(): image_id, is_training_image = line.strip().split(' ') is_training_image = int(is_training_image) if self.phase == 'train' and is_training_image: self.image_id.append(image_id) if self.phase in ('val', 'test') and not is_training_image: self.image_id.append(image_id) # transform self.transform = get_transform(self.resize, self.phase)
def __init__(self, device): self.device = device self.path = PATH_CAT_ATTR_PREDICTOR self.model = torch.load(self.path, map_location=device).to(device) self.model.eval() self.transform = get_transform(normalize=True) self.tasks = ['cat', 'slv', 'neck', 'ubl', 'lbl', 'clos']
def write_geometry(feature, ttlfile): code_epci = feature.GetField("CODE_EPCI") polygon_uri = ign_multipolygon_epci_uri.replace("$", str(code_epci)) geom = feature.GetGeometryRef() geom.Transform(utils.get_transform(2154, 4326)) geom_string = '"' + crs84_uri + ' ' + geom.ExportToWkt( ) + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' # Write polygon output = polygon_uri + ' a ' + ign_multipolygon_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#centroid> ' + ign_centroid_epci_uri.replace( "$", str(code_epci)) + ' .\n' output += '\n' # Write centroid centroid = geom.Centroid() wkt = 'POINT(' + str(centroid.GetX()) + ' ' + str(centroid.GetY()) + ')' geom_string = '"' + crs84_uri + ' ' + wkt + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' output += ign_centroid_epci_uri.replace( "$", str(code_epci)) + ' a ' + ign_point_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordX> "' + str( centroid.GetX()) + '"^^xsd:double ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordY> "' + str( centroid.GetY()) + '"^^xsd:double .\n' output += '\n' ttlfile.write(output)
def store_chef_lieu(feature): statut_chef_lieu = feature.GetFieldAsString("STATUT") insee_commune = feature.GetFieldAsString("INSEE_COM") geom = feature.GetGeometryRef() geom.Transform(utils.get_transform(2154, 4326)) geom_string = str(geom.GetX()) + '|' + str(geom.GetY()) if statut_chef_lieu == "Commune simple": chefs_lieu_commune.update({insee_commune: geom_string}) elif statut_chef_lieu == "Arrondissement municipal": chefs_lieu_commune.update({insee_commune: geom_string}) elif statut_chef_lieu == "Sous-préfecture": chefs_lieu_arrdt.update({insee_commune: geom_string}) chefs_lieu_commune.update({insee_commune: geom_string}) elif statut_chef_lieu == "Préfecture": chefs_lieu_dept.update({insee_commune: geom_string}) chefs_lieu_commune.update({insee_commune: geom_string}) elif statut_chef_lieu == "Préfecture de région": chefs_lieu_region.update({insee_commune: geom_string}) chefs_lieu_dept.update({insee_commune: geom_string}) chefs_lieu_commune.update({insee_commune: geom_string}) elif statut_chef_lieu == "Capitale d'état": chefs_lieu_capitale.update({insee_commune: geom_string}) chefs_lieu_arrdt.update({insee_commune: geom_string}) chefs_lieu_dept.update({insee_commune: geom_string}) chefs_lieu_commune.update({insee_commune: geom_string})
def sample(self, image, question, topk=5): """ Processes a question and image, passes it through the trained net and returns an answer """ question = question.lower().replace("?", "") question = question.split(' ') q, q_len = self.encode_question(question) transform = utils.get_transform(config.image_size, config.central_fraction) inputImg = transform(image) with torch.no_grad(): q = Variable(q.unsqueeze(0)) q_len = Variable(torch.tensor([q_len])) v = Variable(self.resnet(inputImg.unsqueeze(0))) out = self.net(v, q, q_len) out = self.softmax(out) # to get confidence answer = out.data.topk(topk, dim=1) # top k number of answers answers = [] for i in range(topk): answers.append((self.answers[int(answer[1][0][i])], float(answer[0][0][i]))) return answers
def get_loader(image_path, train=False, val=False, test=False): """ Returns a data loader for the desired split """ assert train + val + test == 1, 'need to set exactly one of {train, val, test} to True' split = VQA(utils.path_for(train=train, val=val, test=test, question=True), utils.path_for(train=train, val=val, test=test, answer=True), image_path, answerable_only=train, transform=utils.get_transform(config.image_size, test, config.central_fraction)) if test: loader = torch.utils.data.DataLoader( split, batch_size=config.test_batch_size, shuffle=train, # only shuffle the data in training pin_memory=True, num_workers=config.data_workers, collate_fn=collate_fn, ) else: loader = torch.utils.data.DataLoader( split, batch_size=config.batch_size, shuffle=train, # only shuffle the data in training pin_memory=True, num_workers=config.data_workers, collate_fn=collate_fn, ) return loader
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batch-size', '-bs', type=int, default=64) parser.add_argument('--epochs', type=int, default=20) parser.add_argument('--learning-rate', '-lr', type=float, default=1e-3) parser.add_argument('--layers', '-l', type=int, default=20) parser.add_argument('--channels', '-ch', type=int, default=64) parser.add_argument('--cuda', action='store_true') parser.add_argument('--model-dir', type=str, default='models') parser.add_argument('--parallel', action='store_true') parser.add_argument('--workers', type=int, default=0) parser.add_argument('--log-interval', type=int, default=1000) parser.add_argument('--crop-size', type=int, default=64) args = parser.parse_args() args.cuda = args.cuda and torch.cuda.is_available() os.makedirs(args.model_dir, exist_ok=True) print(args) net = DeepClassAwareDenoiseNet(3, args.channels, args.layers) dataloader = data.DataLoader(NoisyCoco(root='data/train2017', transform=get_transform(), crop_size=args.crop_size), batch_size=args.batch_size, shuffle=True, num_workers=args.workers) solver = Solver(args, net, dataloader) solver.solve()
def loadImage(self, idx): ds = self.ds ## load + crop orig_img = ds.get_img(idx) orig_keypoints = ds.get_kps(idx) kptmp = orig_keypoints.copy() c = ds.get_center(idx) s = ds.get_scale(idx) cropped = utils.crop(orig_img, c, s, (self.input_res, self.input_res)) for i in range(np.shape(orig_keypoints)[1]): if orig_keypoints[0, i, 0] > 0: orig_keypoints[0, i, :2] = utils.transform(orig_keypoints[0, i, :2], c, s, (self.input_res, self.input_res)) keypoints = np.copy(orig_keypoints) ## augmentation -- to be done to cropped image height, width = cropped.shape[0:2] center = np.array((width / 2, height / 2)) scale = max(height, width) / 200 aug_rot = (np.random.random() * 2 - 1) * 30. aug_scale = np.random.random() * (1.25 - 0.75) + 0.75 scale *= aug_scale mat_mask = utils.get_transform(center, scale, (self.output_res, self.output_res), aug_rot)[:2] mat = utils.get_transform(center, scale, (self.input_res, self.input_res), aug_rot)[:2] inp = cv2.warpAffine(cropped, mat, (self.input_res, self.input_res)).astype(np.float32) / 255 keypoints[:, :, 0:2] = utils.kpt_affine(keypoints[:, :, 0:2], mat_mask) if np.random.randint(2) == 0: inp = self.preprocess(inp) inp = inp[:, ::-1] keypoints = keypoints[:, ds.flipped_parts['mpii']] keypoints[:, :, 0] = self.output_res - keypoints[:, :, 0] orig_keypoints = orig_keypoints[:, ds.flipped_parts['mpii']] orig_keypoints[:, :, 0] = self.input_res - orig_keypoints[:, :, 0] ## set keypoints to 0 when were not visible initially (so heatmap all 0s) for i in range(np.shape(orig_keypoints)[1]): if kptmp[0, i, 0] == 0 and kptmp[0, i, 1] == 0: keypoints[0, i, 0] = 0 keypoints[0, i, 1] = 0 orig_keypoints[0, i, 0] = 0 orig_keypoints[0, i, 1] = 0 ## generate heatmaps on outres heatmaps = self.generateHeatmap(keypoints) # inp.transpose return torch.tensor(inp.astype(np.float32)).permute(2, 0, 1), torch.tensor(heatmaps.astype(np.float32))
def __init__(self, questions_path1, questions_path2, answers_path1, answers_path2, image_path, fdict_path, answerable_only=False): super(VQA, self).__init__() with open(questions_path1, 'r') as fd: questions_json1 = json.load(fd) with open(answers_path1, 'r') as fd: answers_json1 = json.load(fd) with open(questions_path2, 'r') as fd: questions_json2 = json.load(fd) with open(answers_path2, 'r') as fd: answers_json2 = json.load(fd) with open(config.vocabulary_path, 'r') as fd: vocab_json = json.load(fd) self._check_integrity(questions_json, answers_json) # vocab self.vocab = vocab_json self.token_to_index = self.vocab['question'] self.answer_to_index = self.vocab['answer'] # q and a self.questions1 = list(prepare_questions(questions_json1)) self.answers1 = list(prepare_answers(answers_json1)) self.questions1 = [self._encode_question(q) for q in self.questions1] self.answers1 = [self._encode_answers(a) for a in self.answers1] self.questions2 = list(prepare_questions(questions_json2)) self.answers2 = list(prepare_answers(answers_json2)) self.questions2 = [self._encode_question(q) for q in self.questions2] self.answers2 = [self._encode_answers(a) for a in self.answers2] # v self.image_path = image_path #self.coco_id_to_index = self._create_coco_id_to_index() self.coco_ids1 = [q['image_id'] for q in questions_json1['questions']] self.coco_ids2 = [q['image_id'] for q in questions_json2['questions']] self.transform = utils.get_transform(config.image_size, config.central_fraction) #self.id_to_filename = self._find_images() self.id_to_filename = np.load(fdict_path).item() self.sorted_ids = sorted(self.id_to_filename.keys() ) # used for deterministic iteration order print('found {} images in {}'.format(len(self.id_to_filename), image_path)) #pdb.set_trace() # only use questions that have at least one answer? self.answerable_only = answerable_only if self.answerable_only: self.answerable = self._find_answerable()
def box_contains_bubbles(self, box, threshold): im = utils.get_transform(box, threshold) contours, _ = cv.findContours(im, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) for contour in contours: if self.is_bubble(contour): return True return False
def load_image(self, path, show=False): transform = utils.get_transform(config.image_size, config.central_fraction) img = Image.open(path).convert('RGB') if show: plt.figure() plt.imshow(img) if transform is not None: img = transform(img) return img
def main(args): device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') print("load dataset") num_classes = 2 data = HandDataset(args.data_path, utils.get_transform(train=True)) indices = torch.randperm(len(data)).tolist() test_cnt = int(len(data) / 10) dataset = torch.utils.data.Subset(data, indices[:-test_cnt]) dataset_test = torch.utils.data.Subset(dataset, indices[-test_cnt:]) # 定义训练和验证数据加载器 data_loader = torch.utils.data.DataLoader( dataset, batch_size=2, shuffle=True, num_workers=4, collate_fn=lambda x: tuple(zip(*x))) data_loader_test = torch.utils.data.DataLoader( dataset_test, batch_size=1, shuffle=False, num_workers=4, collate_fn=lambda x: tuple(zip(*x))) print("load model") model = MaskRcnn.get_pretrained_resnet50_model(num_classes) model.to(device) params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1) print("begin train") num_epochs = 10 for epoch in range(num_epochs): utils.train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10) lr_scheduler.step() # evaluate(model, data_loader_test, device=device) print("That's it!")
def main(): global img parser = argparse.ArgumentParser() parser.add_argument('input_dir', help='path to image.') # parser.add_argument('question', help='question about image') args = parser.parse_args() q = input('Please input the question: ') # Image preprocess img = Image.open(args.input_dir).convert('RGB') transform = utils.get_transform(config.image_size, config.central_fraction) v = transform(img) net = ImageProcessor() net.eval() v = v.unsqueeze(dim=0) with torch.no_grad(): v = net(v) # Question preprocess q = q.lower()[:-1] q = q.split(' ') q_len = torch.tensor([len(q)], dtype=torch.long) max_question_length = 23 with open(config.vocabulary_path, 'r') as fd: vocab_json = json.load(fd) vec = torch.zeros(max_question_length).long() token_to_index = vocab_json['question'] for i, token in enumerate(q): index = token_to_index.get(token, 0) vec[i] = index vec = vec.unsqueeze(dim=0) num_tokens = len(token_to_index) + 1 log = torch.load('2017-08-04_00.55.19.pth', map_location='cpu') net = torch.nn.DataParallel(Net(num_tokens)) net.load_state_dict(log['weights']) net.eval() net.module.apply_attention.register_forward_hook(attn_hook_function) with torch.no_grad(): out = net(v, vec, q_len) conf, ans = out.topk(k=5, dim=1) conf, ans = conf.tolist()[0], ans.tolist()[0] print('TOP 5 PREDICT ANSWER:') for c, a in zip(conf, ans): print(get_key(a, vocab_json['answer']), c)
def get_dataloader(config): transform_img_train, transform_label_train = get_transform(config, is_train=True) transform_img_val, transform_label_val = get_transform(config, is_train=False) train_set = Dataset(config['root'] + '/train', config['size'], transform_img_train, transform_label_train) val_set = Dataset(config['root'] + '/validate', config['size'], transform_img_val, transform_label_val) train_loader = DataLoader(train_set, batch_size=config['batch_size'], shuffle=True, num_workers=0, drop_last=False) val_loader = DataLoader(val_set, batch_size=1, shuffle=False, num_workers=0, drop_last=False) return train_loader, val_loader
def create_coco_loader(path): transform = utils.get_transform(config.image_size, config.central_fraction) dataset = CocoImages(path, transform=transform) data_loader = torch.utils.data.DataLoader( dataset, batch_size=config.preprocess_batch_size, num_workers=config.data_workers, shuffle=False, pin_memory=True, ) return data_loader
def create_vizwiz_loader(*paths): transform = utils.get_transform(config.image_size, config.central_fraction) datasets = [data.VizWizImages(path, transform=transform) for path in paths] dataset = data.Composite(*datasets) data_loader = torch.utils.data.DataLoader( dataset, batch_size=config.preprocess_batch_size, num_workers=config.data_workers, shuffle=False, pin_memory=True, ) return data_loader
def main(): model = Generator(N_RESIDUAL_BLOCKS, USE_DROPOUT) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.load_state_dict(torch.load(MODEL_PATH, map_location=device)) model.eval() transform = get_transform(IMAGE_SIZE) validation_data = torchvision.datasets.ImageFolder( root=VALIDATION_DATA_PATH, transform=transform) for i in range(N_VALIDATION_IMAGES): prediction = model(validation_data[i][0].unsqueeze(0)) save_image(prediction, f'prediction{i}.png', normalize=True)
def write_geometry(feature, ttlfile): insee_arr = feature.GetField("INSEE_ARR") insee_dept = feature.GetField("INSEE_DEP") unique_id = insee_dept + insee_arr # Write polygon geom = feature.GetGeometryRef() geom.Transform(utils.get_transform(2154, 4326)) geom_string = '"' + crs84_uri + ' ' + geom.ExportToWkt( ) + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' polygon_uri = ign_multipolygon_arrondissement_uri.replace("$", unique_id) output = polygon_uri + ' a ' + ign_multipolygon_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#centroid> ' + ign_centroid_arrondissement_uri.replace( "$", unique_id) + ' .\n' output += '\n' # Write centroid centroid = geom.Centroid() wkt = 'POINT(' + str(centroid.GetX()) + ' ' + str(centroid.GetY()) + ')' geom_string = '"' + crs84_uri + ' ' + wkt + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' output += ign_centroid_arrondissement_uri.replace( "$", unique_id) + ' a ' + ign_point_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordX> "' + str( centroid.GetX()) + '"^^xsd:double ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordY> "' + str( centroid.GetY()) + '"^^xsd:double .\n' output += '\n' # Write chef lieu insee_commune = chef_lieu.get_cl_arrdt_commune(insee_dept) if insee_commune is not None: lon, lat, wkt = chef_lieu.get_cl_arrdt_coords_and_wkt(insee_commune) geom_string = '"' + crs84_uri + ' ' + wkt + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' output += ign_cheflieu_arrondissement_uri.replace( "$", insee_commune) + ' a ' + ign_point_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordX> "' + str( lon) + '"^^xsd:double ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#coordY> "' + str( lat) + '"^^xsd:double .\n' output += '\n' ttlfile.write(output)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--input-file', '-i', type=str, default=None, help='Path to an input file.') parser.add_argument( '--model', '-m', type=str, choices=['resnet18Fer2013', 'resnet18KDEF', 'resnet18Dartmouth'], default='resnet18Fer2013', help='Model name.') args = parser.parse_args() input_file_name = args.input_file model_name = args.model img = Image.open(input_file_name) if model_name == 'resnet18Fer2013': net = resnet18() weights = 'resnet18Fer2013.pth' transform = get_transform(48) elif model_name == 'resnet18KDEF': net = resnet18() weights = 'resnet18KDEF.pth' transform = get_transform(224) elif model_name == 'resnet18Dartmouth': net = resnet18() weights = 'resnet18Dartmouth.pth' transform = get_transform(224) path = Path.joinpath(Path(), 'weights', weights) net.load_state_dict(torch.load(path, map_location=torch.device('cpu'))) net.eval() img_tensor = transform(img).unsqueeze(0) with torch.no_grad(): softmax = torch.nn.Softmax(dim=1) preds = softmax(net(img_tensor)).numpy().ravel() for i in range(len(CLASSES)): print('{:>8}: {:5.2f}%'.format(CLASSES[i], 100 * preds[i]))
def predict_fn(input_object, model): print('Inferring class of input data.') tfms = get_transform() input_data = tfms(input_object) device = get_default_device() output = predict_image(input_data, model) return output
def create_coco_loader(*paths): transform = utils.get_transform(config.image_size, config.central_fraction) datasets = [data.CocoImages(path, transform=transform) for path in paths] #ipdb.set_trace() ## datasets[0].__getitem__(116591)[0] print the largest coco_id - this is within torch int64 bound! dataset = data.Composite(*datasets) data_loader = torch.utils.data.DataLoader( dataset, batch_size=config.preprocess_batch_size, num_workers=config.data_workers, shuffle=False, pin_memory=True, ) return data_loader
def main(): args = parse_arguments() # dataset, dataloader transforms = get_transform() train_dataset = Dataset.TrackData_RL(args.train_data, transform=transforms) train_loader = DataLoader(train_dataset, num_workers=args.num_workers, shuffle=True, batch_size=1) # model, environment R = Reinforce(train_loader, transforms) env = Env(args) start_epoch = 1 if args.init_sl: if os.path.isfile(args.init_sl): print("=> loading checkpoint '{}'".format(args.init_sl)) checkpoint = torch.load(args.init_sl) R.agent.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.init_sl)) elif args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) start_epoch = checkpoint['epoch'] R.agent.load_state_dict(checkpoint['state_dict']) R.optim.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) for epoch in range(start_epoch, args.max_epochs + 1): R.train(env, epoch, args.gamma, logging=True) if epoch % args.save_freq == 0: # save model save_checkpoint( { 'epoch': epoch + 1, 'state_dict': R.agent.state_dict(), 'optimizer': R.optim.state_dict(), }, dir='cv/%s/' % args.name)
def write_geometry(feature, ttlfile): insee_region = feature.GetField("INSEE_REG") polygon_uri = ign_multipolygon_region_uri.replace("$", insee_region) geom = feature.GetGeometryRef() geom.Transform(utils.get_transform(2154, 4326)) geom_string = '"' + crs84_uri + ' ' + geom.ExportToWkt( ) + '"^^<http://www.opengis.net/ont/geosparql#wktLiteral>' output = polygon_uri + ' a ' + ign_multipolygon_data_type + ' ;\n' output += '\t' + ' <http://www.opengis.net/ont/geosparql#asWKT> ' + geom_string + ' ;\n' output += '\t' + ' <http://data.ign.fr/def/geometrie#crs> ' + '<http://data.ign.fr/id/ignf/crs/WGS84GDD>' + ' .\n' output += '\n' ttlfile.write(output)
def get_train_data(): normal_train, normal_test = get_sentence(args.train_data, args.test_data) transfer_train, transfer_test = get_sentence(args.transfer_train_data, args.transfer_test_data) char2id, id2char, tag2id, id2tag, transfer_tag2id, transfer_id2tag = get_transform(normal_train + transfer_train, args.map_path, args.tag2label_path, args.transfer_tag2label_path) train_data = preprocess_data(normal_train, char2id, tag2id) train_manager = BatchManager(train_data, args.batch_size) test_data = preprocess_data(normal_test, char2id, tag2id) test_manager = BatchManager(test_data, args.batch_size) transfer_train_data = preprocess_data(transfer_train, char2id, transfer_tag2id) transfer_train_manager = BatchManager(transfer_train_data, args.batch_size) transfer_test_data = preprocess_data(transfer_test, char2id, transfer_tag2id) transfer_test_manager = BatchManager(transfer_test_data, args.batch_size) return train_manager, test_manager, transfer_train_manager, transfer_test_manager, id2char, id2tag, transfer_id2tag