def eval_patch(self):
print("Eval with ", self.ocr_name)
self.prep_model.eval()
ori_lbl_crt_count = 0
ori_lbl_cer = 0
prd_lbl_crt_count = 0
prd_lbl_cer = 0
lbl_count = 0
counter = 0
for image, labels_dict in self.dataset:
text_crops, labels = get_text_stack(
image.detach(), labels_dict, self.input_size)
lbl_count += len(labels)
ocr_labels = self.ocr.get_labels(text_crops)
ori_crt_count, ori_cer = compare_labels(
ocr_labels, labels)
ori_lbl_crt_count += ori_crt_count
ori_lbl_cer += ori_cer
image = image.unsqueeze(0)
X_var = image.to(self.device)
pred = self.prep_model(X_var)
pred = pred.detach().cpu()[0]
pred_crops, labels = get_text_stack(
pred, labels_dict, self.input_size)
pred_labels = self.ocr.get_labels(pred_crops)
prd_crt_count, prd_cer = compare_labels(
pred_labels, labels)
prd_lbl_crt_count += prd_crt_count
prd_lbl_cer += prd_cer
ori_cer = round(ori_cer/len(labels), 2)
prd_cer = round(prd_cer/len(labels), 2)
if self.show_img:
show_img(image.cpu())
if self.show_txt:
self._print_labels(labels, pred_labels, ocr_labels)
counter += 1
print()
print('Correct count from predicted images: {:d}/{:d} ({:.5f})'.format(
prd_lbl_crt_count, lbl_count, prd_lbl_crt_count/lbl_count))
print('Correct count from original images: {:d}/{:d} ({:.5f})'.format(
ori_lbl_crt_count, lbl_count, ori_lbl_crt_count/lbl_count))
print('Average CER from original images: ({:.5f})'.format(
ori_lbl_cer/lbl_count))
print('Average CER from predicted images: ({:.5f})'.format(
prd_lbl_cer/lbl_count))
def eval_area(self):
print("Eval with ", self.ocr_name)
self.prep_model.eval()
pred_correct_count = 0
ori_correct_count = 0
ori_cer = 0
pred_cer = 0
counter = 0
for images, labels, names in self.loader_eval:
X_var = images.to(self.device)
img_preds = self.prep_model(X_var)
ocr_lbl_pred = self.ocr.get_labels(img_preds.cpu())
ocr_lbl_ori = self.ocr.get_labels(images.cpu())
if self.show_txt:
self._print_labels(labels, ocr_lbl_pred, ocr_lbl_ori)
prd_crt_count, prd_cer = compare_labels(
ocr_lbl_pred, labels)
ori_crt_count, o_cer = compare_labels(ocr_lbl_ori, labels)
pred_correct_count += prd_crt_count
ori_correct_count += ori_crt_count
ori_cer += o_cer
pred_cer += prd_cer
if self.show_img:
show_img(img_preds.detach().cpu(), "Processed images")
counter += 1
print()
print('Correct count from predicted images: {:d}/{:d} ({:.5f})'.format(
pred_correct_count, len(self.dataset), pred_correct_count/len(self.dataset)))
print('Correct count from original images: {:d}/{:d} ({:.5f})'.format(
ori_correct_count, len(self.dataset), ori_correct_count/len(self.dataset)))
print('Average CER from original images: {:.5f}'.format(
ori_cer/len(self.dataset)))
print('Average CER from predicted images: {:.5f}'.format(
pred_cer/len(self.dataset)))
def qudit_through_channel(dim, numA, numB, adj_mat, target_node, coef_mat,
param):
input_coef_mat = np.copy(coef_mat)
new_coef_mat = (1 - param) * np.copy(coef_mat)
Alabels = list(product(np.arange(0, dim), repeat=numA))
Blabels = list(product(np.arange(0, dim), repeat=numB))
for x in range(dim**2):
error_label = list(product(np.arange(0, dim), repeat=2))[x]
for row in range(dim**numA):
for col in range(dim**numB):
current_coef = input_coef_mat[row, col]
if current_coef > 0:
labelIn = np.array(Alabels[row] + Blabels[col])
#create list of effected labels
altered = []
labelOut = label_update(dim, adj_mat, target_node, labelIn,
error_label)
if compare_labels(labelOut, labelIn):
altered.append(labelOut)
#print('altered',altered)
#determine which coefficients need to change and change them
for entry in range(np.shape(altered)[0]):
#graphs state basis label of coefficient to be updated
focus = altered[entry]
#get matrix indices of label
id_row, id_col = match_label_to_index(
dim, numA, numB, focus)
#update coeficient matrix
new_coef_mat[id_row,
id_col] += current_coef * (param /
(dim**2 - 1))
return new_coef_mat
def train(self):
step = 0
validation_step = 0
writer = SummaryWriter(properties.prep_tensor_board)
temp_optimizer = optim.Adam(
self.prep_model.parameters(), lr=0.01, weight_decay=0)
temp_loss_fn = MSELoss().to(self.device)
self.prep_model.train()
for images, labels, names in self.loader_train:
self.prep_model.zero_grad()
X_var = images.to(self.device)
preds = self.prep_model(X_var)
loss = temp_loss_fn(preds, X_var)
loss.backward()
temp_optimizer.step()
for epoch in range(self.epochs):
training_loss = 0
self.prep_model.train()
for images, labels, names in self.loader_train:
self.prep_model.zero_grad()
X_var = images.to(self.device)
preds = self.prep_model(X_var)
_, c, h, w = images.shape
grads = torch.zeros_like(images).to(self.device)
batch_loss = 0
for i in range(self.batch_size):
noise = torch.randn(
size=(self.p_samples, c, h, w)).to(self.device)
noise = torch.cat((noise, -noise), dim=0)
noisy_imgs = preds[i] + (noise*self.std)
noisy_imgs = noisy_imgs.view(2*self.p_samples, c, -1)
noisy_imgs -= noisy_imgs.min(2, keepdim=True)[0]
noisy_imgs /= noisy_imgs.max(2, keepdim=True)[0]
noisy_imgs = noisy_imgs.view(2*self.p_samples, c, h, w)
noisy_labels = self.ocr.get_labels(
noisy_imgs.detach().cpu())
loss = self._get_cer(
noisy_labels, [labels[i]]*2*self.p_samples)
mean_loss = loss.mean(dim=0)
batch_loss += mean_loss.item()
loss = loss.unsqueeze(1).unsqueeze(1).unsqueeze(1)
loss = noise*loss.to(self.device)
loss = torch.div(loss.mean(dim=0), self.std)
grads[i] += loss
training_loss += (batch_loss/self.batch_size)
sec_loss = self.secondary_loss_fn(preds, torch.ones(
preds.shape).to(self.device))*self.sec_loss_scalar
sec_loss.backward(retain_graph=True)
preds.backward(grads)
self.optimizer.step()
if step % 500 == 0:
print("Iteration: %d => %f" %
(step, batch_loss/self.batch_size))
step += 1
writer.add_scalar('Training Loss', training_loss /
(self.train_set_size//self.batch_size), epoch + 1)
self.prep_model.eval()
validation_loss = 0
tess_crt_count = 0
tess_CER = 0
with torch.no_grad():
for images, labels, names in self.loader_validation:
X_var = images.to(self.device)
img_preds = self.prep_model(X_var)
ocr_labels = self.ocr.get_labels(img_preds.detach().cpu())
loss = self._get_cer(ocr_labels, labels)
mean_loss = loss.mean(dim=0)
validation_loss += mean_loss.item()
tess_crt, tess_cer = compare_labels(ocr_labels, labels)
tess_crt_count += tess_crt
tess_CER += tess_cer
validation_step += 1
writer.add_scalar('Accuracy/'+self.ocr_name+'_output',
tess_crt_count/self.val_set_size, epoch + 1)
writer.add_scalar('WER and CER/'+self.ocr_name+'_CER',
tess_CER/self.val_set_size, epoch + 1)
writer.add_scalar('Validation Loss', validation_loss /
(self.val_set_size//self.batch_size), epoch + 1)
save_img(img_preds.cpu(), 'out_' +
str(epoch), properties.img_out_path)
if epoch == 0:
save_img(images.cpu(), 'out_original', properties.img_out_path)
print("%s correct count: %d; (validation set size:%d)" % (
self.ocr_name, tess_crt_count, self.val_set_size))
print("%s CER: %d;" % (self.ocr_name, tess_CER))
print("Epoch: %d/%d => Training loss: %f | Validation loss: %f" % ((epoch + 1),
self.epochs, training_loss /
(self.train_set_size //
self.batch_size),
validation_loss/(self.val_set_size//self.batch_size)))
torch.save(self.prep_model,
properties.prep_model_path + "Prep_model_"+str(epoch))
torch.save({
'epoch': epoch,
'prep_model_state_dict': self.prep_model.state_dict(),
'optimizer_state_dict': self.optimizer.state_dict(),
}, properties.prep_model_path + "state_"+str(epoch))
writer.flush()
writer.close()
def train(self):
noiser = AddGaussianNoice(
std=self.std, is_stochastic=self.is_random_std)
writer = SummaryWriter(properties.prep_tensor_board)
step = 0
validation_step = 0
batch_step = 0
for epoch in range(0, self.max_epochs):
training_loss = 0
for images, labels_dicts, names in self.loader_train:
self.crnn_model.train()
self.prep_model.eval()
self.prep_model.zero_grad()
self.crnn_model.zero_grad()
CRNN_training_loss = 0
for i in range(len(labels_dicts)):
image = images[i]
labels_dict = labels_dicts[i]
image = image.unsqueeze(0)
X_var = image.to(self.device)
pred = self.prep_model(X_var)
pred = pred.detach().cpu()[0]
text_crops, labels = get_text_stack(
pred, labels_dict, self.input_size)
temp_loss = 0
for i in range(self.inner_limit):
self.prep_model.zero_grad()
noisy_imgs = self.add_noise(text_crops, noiser)
noisy_labels = self.ocr.get_labels(noisy_imgs)
scores, y, pred_size, y_size = self._call_model(
noisy_imgs, noisy_labels)
loss = self.primary_loss_fn(
scores, y, pred_size, y_size)
temp_loss += loss.item()
loss.backward()
CRNN_training_loss += temp_loss/self.inner_limit
self.optimizer_crnn.step()
writer.add_scalar('CRNN Training Loss',
CRNN_training_loss, batch_step)
batch_step += 1
self.prep_model.train()
self.crnn_model.train()
self.crnn_model.apply(set_bn_eval)
self.prep_model.zero_grad()
self.crnn_model.zero_grad()
for i in range(len(labels_dicts)):
image = images[i]
labels_dict = labels_dicts[i]
image = image.unsqueeze(0)
X_var = image.to(self.device)
img_out = self.prep_model(X_var)[0]
n_text_crops, labels = get_text_stack(
img_out, labels_dict, self.input_size)
scores, y, pred_size, y_size = self._call_model(
n_text_crops, labels)
loss = self._get_loss(
scores, y, pred_size, y_size, img_out)
loss.backward()
training_loss += loss.item()
if step % 100 == 0:
print("Iteration: %d => %f" % (step, loss.item()))
step += 1
self.optimizer_prep.step()
writer.add_scalar('Training Loss', training_loss /
self.train_set_size, epoch + 1)
self.prep_model.eval()
self.crnn_model.eval()
pred_correct_count = 0
validation_loss = 0
tess_correct_count = 0
label_count = 0
with torch.no_grad():
for image, labels_dict in self.validation_set:
image = image.unsqueeze(0)
X_var = image.to(self.device)
img_out = self.prep_model(X_var)[0]
n_text_crops, labels = get_text_stack(
img_out, labels_dict, self.input_size)
scores, y, pred_size, y_size = self._call_model(
n_text_crops, labels)
loss = self._get_loss(
scores, y, pred_size, y_size, img_out)
validation_loss += loss.item()
preds = pred_to_string(scores, labels, self.index_to_char)
ocr_labels = self.ocr.get_labels(n_text_crops.cpu())
crt, _ = compare_labels(preds, labels)
tess_crt, _ = compare_labels(ocr_labels, labels)
pred_correct_count += crt
tess_correct_count += tess_crt
label_count += len(labels)
validation_step += 1
writer.add_scalar('Accuracy/CRNN_output',
pred_correct_count/label_count, epoch + 1)
writer.add_scalar('Accuracy/'+self.ocr_name+'_output',
tess_correct_count/label_count, epoch + 1)
writer.add_scalar('Validation Loss',
validation_loss/self.val_set_size, epoch + 1)
img = transforms.ToPILImage()(img_out.cpu()[0])
img.save(properties.img_out_path+'out_'+str(epoch)+'.png', 'PNG')
if epoch == 0:
img = transforms.ToPILImage()(image.cpu()[0])
img.save(properties.img_out_path+'out_original.png', 'PNG')
print("CRNN correct count: %d; %s correct count: %d; (validation set size:%d)" % (
pred_correct_count, self.ocr_name, tess_correct_count, label_count))
print("Epoch: %d/%d => Training loss: %f | Validation loss: %f" % ((epoch + 1), self.max_epochs,
training_loss / self.train_set_size,
validation_loss/self.val_set_size))
torch.save(self.prep_model,
properties.prep_model_path + "Prep_model_"+str(epoch))
torch.save(self.crnn_model, properties.prep_model_path +
"CRNN_model_" + str(epoch))
writer.flush()
writer.close()
def train(self):
noiser = AddGaussianNoice(std=self.std,
is_stochastic=self.is_random_std)
writer = SummaryWriter(properties.prep_tensor_board)
step = 0
validation_step = 0
self.crnn_model.zero_grad()
for epoch in range(self.max_epochs):
training_loss = 0
for images, labels, names in self.loader_train:
self.crnn_model.train()
self.prep_model.eval()
self.prep_model.zero_grad()
self.crnn_model.zero_grad()
X_var = images.to(self.device)
img_preds = self.prep_model(X_var)
img_preds = img_preds.detach().cpu()
temp_loss = 0
for i in range(self.inner_limit):
self.prep_model.zero_grad()
noisy_imgs = self.add_noise(img_preds, noiser)
noisy_labels = self.ocr.get_labels(noisy_imgs)
scores, y, pred_size, y_size = self._call_model(
noisy_imgs, noisy_labels)
loss = self.primary_loss_fn(scores, y, pred_size, y_size)
temp_loss += loss.item()
loss.backward()
CRNN_training_loss = temp_loss / self.inner_limit
self.optimizer_crnn.step()
writer.add_scalar('CRNN Training Loss', CRNN_training_loss,
step)
self.prep_model.train()
self.crnn_model.train()
self.crnn_model.apply(set_bn_eval)
self.prep_model.zero_grad()
self.crnn_model.zero_grad()
img_preds = self.prep_model(X_var)
scores, y, pred_size, y_size = self._call_model(
img_preds, labels)
loss = self._get_loss(scores, y, pred_size, y_size, img_preds)
loss.backward()
self.optimizer_prep.step()
training_loss += loss.item()
if step % 100 == 0:
print("Iteration: %d => %f" % (step, loss.item()))
step += 1
writer.add_scalar(
'Training Loss',
training_loss / (self.train_set_size // self.batch_size),
epoch + 1)
self.prep_model.eval()
self.crnn_model.eval()
pred_correct_count = 0
pred_CER = 0
validation_loss = 0
tess_accuracy = 0
tess_CER = 0
with torch.no_grad():
for images, labels, names in self.loader_validation:
X_var = images.to(self.device)
img_preds = self.prep_model(X_var)
scores, y, pred_size, y_size = self._call_model(
img_preds, labels)
loss = self._get_loss(scores, y, pred_size, y_size,
img_preds)
validation_loss += loss.item()
preds = pred_to_string(scores, labels, self.index_to_char)
ocr_labels = self.ocr.get_labels(img_preds.cpu())
crt, cer = compare_labels(preds, labels)
tess_crt, tess_cer = compare_labels(ocr_labels, labels)
pred_correct_count += crt
tess_accuracy += tess_crt
pred_CER += cer
tess_CER += tess_cer
validation_step += 1
writer.add_scalar('Accuracy/CRNN_output',
pred_correct_count / self.val_set_size,
epoch + 1)
writer.add_scalar('Accuracy/' + self.ocr_name + '_output',
tess_accuracy / self.val_set_size, epoch + 1)
writer.add_scalar('WER and CER/CRNN_CER',
pred_CER / self.val_set_size, epoch + 1)
writer.add_scalar('WER and CER/' + self.ocr_name + '_CER',
tess_CER / self.val_set_size, epoch + 1)
writer.add_scalar(
'Validation Loss',
validation_loss / (self.val_set_size // self.batch_size),
epoch + 1)
save_img(img_preds.cpu(), 'out_' + str(epoch),
properties.img_out_path, 8)
if epoch == 0:
save_img(images.cpu(), 'out_original', properties.img_out_path,
8)
print(
"CRNN correct count: %d; %s correct count: %d; (validation set size:%d)"
% (pred_correct_count, self.ocr_name, tess_accuracy,
self.val_set_size))
print("CRNN CER:%d; %s CER: %d;" %
(pred_CER, self.ocr_name, tess_CER))
print("Epoch: %d/%d => Training loss: %f | Validation loss: %f" %
((epoch + 1), self.max_epochs, training_loss /
(self.train_set_size // self.batch_size), validation_loss /
(self.val_set_size // self.batch_size)))
torch.save(self.prep_model,
properties.prep_model_path + "Prep_model_" + str(epoch))
torch.save(self.crnn_model,
properties.prep_model_path + "CRNN_model_" + str(epoch))
writer.flush()
writer.close()
def qudit_through_channel(dim, numA, numB, adj_mat, target_node, state_copy,
coef_mat, param):
input_coef_mat = np.copy(coef_mat)
new_coef_mat = (1 - param) * np.copy(coef_mat)
Alabels = list(product(np.arange(0, dim), repeat=numA))
Blabels = list(product(np.arange(0, dim), repeat=numB))
for x in range(dim**2):
error_label = list(product(np.arange(0, dim), repeat=2))[x]
for row in range(dim**(2 * numA)):
for col in range(dim**(2 * numB)):
indA1, indA2, indB1, indB2 = get_two_state_indices(
dim, numA, numB, row, col)
current_coef = input_coef_mat[row, col]
if state_copy == 'first':
if current_coef > 0:
labelIn = np.array(Alabels[indA1] + Blabels[indB1])
#create list of effected labels
altered = []
labelOut = label_update(dim, adj_mat, target_node,
labelIn, error_label)
if compare_labels(labelOut, labelIn):
altered.append(labelOut)
#determine which coefficients need to change and change them
try:
for entry in range(np.shape(altered)[0]):
#graphs state basis label of coefficient to be updated
focus = altered[entry]
#get matrix indices of label
id_indA1, id_indB1 = match_label_to_index(
dim, numA, numB, focus)
#convert back to row and col of new_coef_mat
id_row, id_col = index_convert(
dim, numA, numB, id_indA1, id_indB1, indA2,
indB2)
#update coeficient matrix
new_coef_mat[id_row, id_col] += current_coef * (
param / (dim**2 - 1))
except UnboundLocalError:
continue
elif state_copy == 'second':
if current_coef > 0:
labelIn = np.array(Alabels[indA2] + Blabels[indB2])
#create list of effected labels
altered = []
labelOut = label_update(dim, adj_mat, target_node,
labelIn, error_label)
if compare_labels(labelOut, labelIn):
altered.append(labelOut)
try:
#determine which coefficients need to change and change them
for entry in range(np.shape(altered)[0]):
#graphs state basis label of coefficient to be updated
focus = altered[entry]
#get matrix indices of label
id_indA2, id_indB2 = match_label_to_index(
dim, numA, numB, focus)
#convert back to row and col of new_coef_mat
id_row, id_col = index_convert(
dim, numA, numB, indA1, indB1, id_indA2,
id_indB2)
#update coeficient matrix
new_coef_mat[id_row, id_col] += current_coef * (
param / (dim**2 - 1))
except UnboundLocalError:
continue
return new_coef_mat