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')
