def next_valid_batch(self): """Get the next batch from validation partition (yield)""" while True: if self.valid_index >= self.total_valid: self.valid_index = 0 index = self.valid_index until = self.valid_index + self.batch_size self.valid_index += self.batch_size x_valid = self.dataset["valid"]["dt"][index:until] y_valid = self.dataset["valid"]["gt"][index:until] x_valid_len = np.asarray( [self.tokenizer.maxlen for _ in range(self.batch_size)]) y_valid_len = np.asarray( [len(y_valid[i]) for i in range(self.batch_size)]) x_valid = pp.normalization(x_valid) y_valid = [self.tokenizer.encode(y) for y in y_valid] y_valid = pad_sequences(y_valid, maxlen=self.tokenizer.maxlen, padding="post") inputs = { "input": x_valid, "labels": y_valid, "input_length": x_valid_len, "label_length": y_valid_len } output = {"CTCloss": np.zeros(self.batch_size)} yield (inputs, output)
def getNext(self,train = True): "iterator" self.train = train if self.train == True: j = 0 else: j = 1 while True: if self.currIdx <= len(self.img_partitions[j]): index = self.currIdx until = self.currIdx + self.batchSize else: index = self.currIdx until = len(self.img_partitions[j]) imgs = [pp.preprocess(os.path.join(self.filePath,self.img_partitions[j][i].filePath),self.imgSize) for i in range(index,until)] imgs = pp.augmentation(imgs, rotation_range=1.5, scale_range=0.05, height_shift_range=0.025, width_shift_range=0.05, erode_range=5, dilate_range=3) imgs = pp.normalization(imgs) gtTexts = [self.img_partitions[j][i].gtText for i in range(index,until)] gtTexts = [self.tokenizer.encode(gtTexts[i]) for i in range(len(gtTexts))] gtTexts = [np.pad(i, (0, self.tokenizer.maxlen - len(i))) for i in gtTexts] gtTexts = np.asarray(gtTexts, dtype=np.int16) yield(imgs,gtTexts)
def next_train_batch(self): """Get the next batch from train partition (yield)""" while True: if self.train_index >= self.total_train: self.train_index = 0 index = self.train_index until = self.train_index + self.batch_size self.train_index += self.batch_size x_train = self.dataset["train"]["dt"][index:until] y_train = self.dataset["train"]["gt"][index:until] x_train = pp.augmentation(x_train, rotation_range=1.5, scale_range=0.05, height_shift_range=0.025, width_shift_range=0.05, erode_range=5, dilate_range=3) x_train = pp.normalization(x_train) x_train_len = np.asarray([self.max_text_length for _ in range(self.batch_size)]) y_train_len = np.asarray([len(np.trim_zeros(y_train[i])) for i in range(self.batch_size)]) inputs = { "input": x_train, "labels": y_train, "input_length": x_train_len, "label_length": y_train_len } output = {"CTCloss": np.zeros(self.batch_size)} yield (inputs, output)
def next_valid_batch(self): """Get the next batch from validation partition (yield)""" while True: if self.valid_index >= self.total_valid: self.valid_index = 0 index = self.valid_index until = self.valid_index + self.batch_size self.valid_index += self.batch_size x_valid = self.dataset["valid"]["dt"][index:until] y_valid = self.dataset["valid"]["gt"][index:until] x_valid = pp.normalization(x_valid) x_valid_len = np.asarray([self.max_text_length for _ in range(self.batch_size)]) y_valid_len = np.asarray([len(np.trim_zeros(y_valid[i])) for i in range(self.batch_size)]) inputs = { "input": x_valid, "labels": y_valid, "input_length": x_valid_len, "label_length": y_valid_len } output = {"CTCloss": np.zeros(self.batch_size)} yield (inputs, output)
def next_valid_batch(self): """Get the next batch from validation partition (yield)""" while True: if self.index['valid'] >= self.size['valid']: self.index['valid'] = 0 index = self.index['valid'] until = self.index['valid'] + self.batch_size self.index['valid'] += self.batch_size x_valid = self.dataset['valid']['dt'][index:until] y_valid = self.dataset['valid']['gt'][index:until] x_valid_len = np.asarray([self.tokenizer.maxlen for _ in range(self.batch_size)]) y_valid_len = np.asarray([len(y_valid[i]) for i in range(self.batch_size)]) x_valid = pp.normalization(x_valid) y_valid = [self.tokenizer.encode(y) for y in y_valid] y_valid = pad_sequences(y_valid, maxlen=self.tokenizer.maxlen, padding="post") inputs = { "input": x_valid, "labels": y_valid, "input_length": x_valid_len, "label_length": y_valid_len } output = {"CTCloss": np.zeros(self.batch_size, dtype=int)} # x, y and sample_weight yield (inputs, output, [])
def next_valid_batch(self): """Get the next batch from validation partition (yield)""" self.index['valid'] = 0 while True: if self.index['valid'] >= self.size['valid']: self.index['valid'] = 0 index = self.index['valid'] until = index + self.batch_size self.index['valid'] = until x_valid = self.dataset['valid']['dt'][index:until] x_valid = pp.normalization(x_valid) y_valid = [ self.tokenizer.encode(y) for y in self.dataset['valid']['gt'][index:until] ] y_valid = [ np.pad(y, (0, self.tokenizer.maxlen - len(y))) for y in y_valid ] y_valid = np.asarray(y_valid, dtype=np.int16) yield (x_valid, y_valid)
def next_train_batch(self): """Get the next batch from train partition (yield)""" while True: if self.index['train'] >= self.size['train']: self.index['train'] = 0 index = self.index['train'] until = self.index['train'] + self.batch_size self.index['train'] = until x_train = self.dataset['train']['dt'][index:until] y_train = self.dataset['train']['gt'][index:until] x_train = pp.augmentation(x_train, rotation_range=1.5, scale_range=0.05, height_shift_range=0.025, width_shift_range=0.05, erode_range=5, dilate_range=3) x_train = pp.normalization(x_train) y_train = [self.tokenizer.encode(y) for y in y_train] y_train = pad_sequences(y_train, maxlen=self.tokenizer.maxlen, padding="post") yield (x_train, y_train, [])
def next_train_batch(self): """Get the next batch from train partition (yield)""" while True: if self.index['train'] >= self.size['train']: self.index['train'] = 0 index = self.index['train'] until = self.index['train'] + self.batch_size self.index['train'] = until x_train = self.dataset['train']['dt'][index:until] x_train = pp.augmentation(x_train, rotation_range=1.5, scale_range=0.05, height_shift_range=0.025, width_shift_range=0.05, erode_range=5, dilate_range=3) x_train = pp.normalization(x_train) y_train = [ self.tokenizer.encode(y) for y in self.dataset['train']['gt'][index:until] ] y_train = [ np.pad(y, (0, self.tokenizer.maxlen - len(y))) for y in y_train ] y_train = np.asarray(y_train, dtype=np.int16) yield (x_train, y_train)
def read_text_from_image(self, img): img = pp.preprocess(img, input_size=self.input_size) x_test = pp.normalization([img]) predicts, probabilities = self.model.predict(x_test, ctc_decode=True) predicts = [[self.tokenizer.decode(x) for x in y] for y in predicts] for i, (pred, prob) in enumerate(zip(predicts, probabilities)): return pred[0] return ""
def next_test_batch(self): """Return model predict parameters""" while True: if self.index['test'] >= self.size['test']: break index = self.index['test'] until = self.index['test'] + self.batch_size self.index['test'] = until x_test = self.dataset['test']['dt'][index:until] x_test = pp.normalization(x_test) yield x_test
def next_test_batch(self): """return modeli tahmin parametreleri""" while True: if self.index['test'] >= self.size['test']: self.index['test'] = 0 break index = self.index['test'] until = self.index['test'] + self.batch_size self.index['test'] = until x_test = self.dataset['test']['dt'][index:until] x_test = pp.normalization(x_test) yield x_test
def next_test_batch(self): """Return model predict parameters""" while True: if self.test_index >= self.total_test: self.test_index = 0 index = self.test_index until = self.test_index + self.batch_size self.test_index += self.batch_size x_test = self.dataset["test"]["dt"][index:until] x_test = pp.normalization(x_test) x_test_len = np.asarray([self.max_text_length for _ in range(self.batch_size)]) yield (x_test, x_test_len)
def next_test_batch(self): """Return model predict parameters""" while True: if self.index['test'] >= self.size['test']: break index = self.index['test'] until = self.index['test'] + self.batch_size self.index['test'] += self.batch_size x_test = self.dataset['test']['dt'][index:until] x_test = pp.normalization(x_test) x_test_len = np.asarray([self.tokenizer.maxlen for _ in range(self.batch_size)]) yield [x_test, x_test_len]
def model_test(line_img): img = cv.imread(line_img, 0) img = cv.bitwise_not(img) img = np.repeat(img[..., np.newaxis], 3, -1) img = pp.normalization(img) prep = T.Compose([ T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) test_tensor = prep(img) test_batch = test_tensor.unsqueeze(0) modelito = model.make_model(2) h = modelito.forward(test_batch) tensor_2_numpy = np.transpose(h.detach().numpy()) return 0
def __getitem__(self, i): img = self.dataset[self.split]['dt'][i] #making image compatible with resnet img = np.repeat(img[..., np.newaxis],3, -1) img = pp.normalization(img) if self.transform is not None: img = self.transform(img) y_train = self.tokenizer.encode(self.dataset[self.split]['gt'][i]) #padding till max length y_train = np.pad(y_train, (0, self.tokenizer.maxlen - len(y_train))) gt = torch.Tensor(y_train) return img, gt
def next_train_batch(self): """Get the next batch from train partition (yield)""" while True: if self.index['train'] >= self.size['train']: self.index['train'] = 0 index = self.index['train'] until = self.index['train'] + self.batch_size self.index['train'] += self.batch_size x_train = self.dataset['train']['dt'][index:until] y_train = self.dataset['train']['gt'][index:until] x_train_len = np.asarray([self.tokenizer.maxlen for _ in range(self.batch_size)]) y_train_len = np.asarray([len(y_train[i]) for i in range(self.batch_size)]) x_train = pp.augmentation(x_train, rotation_range=1.5, scale_range=0.05, height_shift_range=0.025, width_shift_range=0.05, erode_range=5, dilate_range=3) x_train = pp.normalization(x_train) y_train = [self.tokenizer.encode(y) for y in y_train] y_train = pad_sequences(y_train, maxlen=self.tokenizer.maxlen, padding="post") inputs = { "input": x_train, "labels": y_train, "input_length": x_train_len, "label_length": y_train_len } output = {"CTCloss": np.zeros(self.batch_size, dtype=int)} # x, y and sample_weight yield (inputs, output, [])
def next_valid_batch(self): """Get the next batch from validation partition (yield)""" while True: if self.index['valid'] >= self.size['valid']: self.index['valid'] = 0 index = self.index['valid'] until = self.index['valid'] + self.batch_size self.index['valid'] = until x_valid = self.dataset['valid']['dt'][index:until] y_valid = self.dataset['valid']['gt'][index:until] x_valid = pp.normalization(x_valid) y_valid = [self.tokenizer.encode(y) for y in y_valid] y_valid = pad_sequences(y_valid, maxlen=self.tokenizer.maxlen, padding="post") yield (x_valid, y_valid, [])
def next_valid_batch(self): """validation bölümünden bir sonraki iş toplu olarak alınır (yield)""" while True: if self.index['valid'] >= self.size['valid']: self.index['valid'] = 0 index = self.index['valid'] until = self.index['valid'] + self.batch_size self.index['valid'] = until x_valid = self.dataset['valid']['dt'][index:until] y_valid = self.dataset['valid']['gt'][index:until] x_valid = pp.normalization(x_valid) y_valid = [self.tokenizer.encode(y) for y in y_valid] y_valid = pad_sequences(y_valid, maxlen=self.tokenizer.maxlen, padding="post") yield (x_valid, y_valid, [])
predicts = [line[5:] for line in lg if line.startswith("TE_P")] for x in range(len(dt)): print(f"Image shape:\t{dt[x].shape}") print(f"Ground truth:\t{gt[x].decode()}") print(f"Predict:\t{predicts[x]}\n") cv2.imshow("img", pp.adjust_to_see(dt[x])) cv2.waitKey(0) elif args.image: tokenizer = Tokenizer(chars=charset_base, max_text_length=max_text_length) img = pp.preproc(args.image, input_size=input_size) x_test = pp.normalization([img]) model = HTRModel(architecture=args.arch, input_size=input_size, vocab_size=tokenizer.vocab_size, top_paths=10) model.compile() model.load_checkpoint(target=target_path) predicts, probabilities = model.predict(x_test, ctc_decode=True) predicts = [[tokenizer.decode(x) for x in y] for y in predicts] print("\n####################################") for i, (pred, prob) in enumerate(zip(predicts, probabilities)): print("\nProb. - Predict")
compression_opts=9) hf.create_dataset(f"{i}/gt", data=ds.dataset[i]['gt'], compression="gzip", compression_opts=9) print(f"[OK] {i} partition.") print(f"Transformation finished.") elif args.image: img = pp.preprocess(args.image, input_size=input_size) #making image compitable with resnet img = np.repeat(img[..., np.newaxis], 3, -1) x_test = pp.normalization(img) model = make_model(tokenizer.vocab_size, hidden_dim=256, nheads=4, num_encoder_layers=4, num_decoder_layers=4) device = torch.device(args.device) model.to(device) transform = T.Compose([T.ToTensor()]) if os.path.exists(target_path): model.load_state_dict(torch.load(target_path)) else: print('No model checkpoint found')