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