| """
|
| Most of the code in this file is derived from the paper "Image-based table recognition: data, model, and evaluation".
|
| The original paper can be accessed at: https://arxiv.org/pdf/1911.10683.
|
| The code is available at: https://github.com/ibm-aur-nlp/PubTabNet.
|
| A slight modification has been added to the code to improve the evaluation process.
|
| """
|
|
|
| import re
|
| import distance
|
| import pandas as pd
|
| from lxml import etree, html
|
| from collections import deque
|
| from apted.helpers import Tree
|
| from apted import APTED, Config
|
| from bs4 import BeautifulSoup
|
|
|
|
|
| class TableTree(Tree):
|
| """Table Tree class for APTED"""
|
| def __init__(self, tag, colspan=None, rowspan=None, content=None, *children):
|
| self.tag = tag
|
| self.colspan = colspan
|
| self.rowspan = rowspan
|
| self.content = content
|
| self.children = list(children)
|
|
|
| def bracket(self):
|
| """Show tree using brackets notation"""
|
| if self.tag == 'td':
|
| result = '"tag": %s, "colspan": %d, "rowspan": %d, "text": %s' % \
|
| (self.tag, self.colspan, self.rowspan, self.content)
|
| else:
|
| result = '"tag": %s' % self.tag
|
| for child in self.children:
|
| result += child.bracket()
|
| return "{{{}}}".format(result)
|
|
|
|
|
| class CustomConfig(Config):
|
| """Custom Configuration for APTED"""
|
| @staticmethod
|
| def maximum(*sequences):
|
| """Get maximum possible value"""
|
| return max(map(len, sequences))
|
|
|
| def normalized_distance(self, *sequences):
|
| """Get distance from 0 to 1"""
|
| return float(distance.levenshtein(*sequences)) / self.maximum(*sequences)
|
|
|
| def rename(self, node1, node2):
|
| """Compares attributes of trees"""
|
| if (node1.tag != node2.tag) or \
|
| (node1.colspan != node2.colspan) or \
|
| (node1.rowspan != node2.rowspan):
|
| return 1.
|
| if node1.tag == 'td':
|
| if node1.content or node2.content:
|
| return self.normalized_distance(
|
| node1.content, node2.content
|
| )
|
| return 0.
|
|
|
|
|
| class TEDSEvaluator(object):
|
| """Tree Edit Distance basead Similarity"""
|
| def __init__(self, structure_only=False, n_jobs=1, ignore_nodes=None):
|
| assert isinstance(n_jobs, int) and (n_jobs >= 1), (
|
| 'n_jobs must be an integer greather than 1'
|
| )
|
| self.structure_only = structure_only
|
| self.n_jobs = n_jobs
|
| self.ignore_nodes = ignore_nodes
|
| self.__tokens__ = []
|
|
|
| def tokenize(self, node):
|
| """Tokenizes table cells"""
|
| self.__tokens__.append('<%s>' % node.tag)
|
| if node.text is not None:
|
| self.__tokens__ += list(node.text)
|
| for n in node.getchildren():
|
| self.tokenize(n)
|
| if node.tag != 'unk':
|
| self.__tokens__.append('</%s>' % node.tag)
|
| if node.tag != 'td' and node.tail is not None:
|
| self.__tokens__ += list(node.tail)
|
|
|
| def load_html_tree(self, node, parent=None):
|
| """Converts HTML tree to the format required by apted"""
|
| global __tokens__
|
| if node.tag == 'td':
|
| if self.structure_only:
|
| cell = []
|
| else:
|
| self.__tokens__ = []
|
| self.tokenize(node)
|
| cell = self.__tokens__[1:-1].copy()
|
| new_node = TableTree(
|
| node.tag,
|
| int(node.attrib.get('colspan', '1')),
|
| int(node.attrib.get('rowspan', '1')),
|
| cell, *deque()
|
| )
|
| else:
|
| new_node = TableTree(node.tag, None, None, None, *deque())
|
| if parent is not None:
|
| parent.children.append(new_node)
|
| if node.tag != 'td':
|
| for n in node.getchildren():
|
| self.load_html_tree(n, new_node)
|
| if parent is None:
|
| return new_node
|
|
|
| def evaluate(self, pred, true):
|
| """Computes TEDS score between the prediction and the ground truth of a given sample"""
|
| if (not pred) or (not true):
|
| return 0.0
|
| parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
|
| pred = html.fromstring(pred, parser=parser)
|
| true = html.fromstring(true, parser=parser)
|
|
|
| if pred.xpath('body/table') and true.xpath('body/table'):
|
| pred = pred.xpath('body/table')[0]
|
| true = true.xpath('body/table')[0]
|
| if self.ignore_nodes:
|
| etree.strip_tags(pred, *self.ignore_nodes)
|
| etree.strip_tags(true, *self.ignore_nodes)
|
| n_nodes_pred = len(pred.xpath('.//*'))
|
| n_nodes_true = len(true.xpath('.//*'))
|
| n_nodes = max(n_nodes_pred, n_nodes_true)
|
| tree_pred = self.load_html_tree(pred)
|
| tree_true = self.load_html_tree(true)
|
| distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
|
| return 1.0 - (float(distance) / n_nodes)
|
| else:
|
| return 0.0
|
|
|
|
|
| def get_table_contents(text):
|
|
|
| table_contents = re.findall(r'<table[^>]*?>(.*?)</table>', text, flags=re.DOTALL)
|
|
|
| if len(table_contents) == 0:
|
| table_contents = [text]
|
|
|
| return table_contents
|
|
|
| def clean_table(html):
|
| soup = BeautifulSoup(html, 'html.parser')
|
|
|
|
|
| for tag in soup.find_all(['table', 'thead', 'tbody']):
|
| tag.unwrap()
|
|
|
|
|
| for tag in soup.find_all():
|
| tag.attrs = {key: value for key, value in tag.attrs.items() if key != 'class'}
|
|
|
| return '\n'.join(str(tag) for tag in soup.find_all('tr'))
|
|
|
| def extract_tables(data : dict) -> str:
|
| """Extract tables from the dictionary data.
|
|
|
| Args:
|
| data (dict): The data to extract tables from.
|
|
|
| Returns:
|
| str: The extracted tables from the data and a boolean indicating if the data has a table.
|
| """
|
|
|
|
|
| html = '<html><body>'
|
| for elem in data['elements']:
|
| if elem['category'].lower() == 'table':
|
| table_html_elements = get_table_contents(clean_table(elem['content']['html']))
|
|
|
| for table_html in table_html_elements:
|
| html += f'<table>{table_html}</table>'
|
|
|
| html += '</body></html>'
|
|
|
| return html
|
|
|
|
|
| def has_table_content(html_data : str) -> bool:
|
| """Check if the table has content between <html><body> and </body></html>.
|
|
|
| Args:
|
| html_data (str): The html data to check.
|
| Returns:
|
| bool: True if the table has content, False otherwise
|
| """
|
| has_content = True
|
| if html_data.replace('<html><body>', '').replace('</body></html>', '') == '':
|
| has_content = False
|
|
|
| return has_content
|
|
|
|
|
| def prepare_table_dataset(gt_data, pred_data):
|
| """Prepare the tables for evaluation.
|
| Args:
|
| gt_data (dict): The ground truth dataset to evaluate.
|
| pred_data (dict): The predicted dataset to evaluate.
|
|
|
| Returns:
|
| tuple (list, list): The list of ground truth and predicted tables.
|
| """
|
|
|
| gt_table_list = []
|
| pred_table_list = []
|
| for image_key in gt_data.keys():
|
|
|
| gt_elem = gt_data.get(image_key)
|
| pred_elem = pred_data.get(image_key)
|
|
|
|
|
|
|
| gt_tables = extract_tables(gt_elem)
|
| pred_tables = extract_tables(pred_elem)
|
|
|
| if not has_table_content(gt_tables):
|
| continue
|
|
|
| gt_table_list.append(gt_tables)
|
| pred_table_list.append(pred_tables)
|
|
|
| return gt_table_list, pred_table_list
|
|
|
|
|
| def calc_table_score(gt_string, pred_string, evaluator):
|
| """Calculate the table evaluation score between the gold and pred strings.
|
|
|
| Args:
|
| gt_string (str): The ground truth html string to compare.
|
| pred_string (str): The predicted html string to compare.
|
| evaluator (TEDS/TEDS-S): The TEDS/TEDS-S evaluator to use.
|
| Returns:
|
| float: The table evaluation score.
|
| """
|
| refined_pred = pred_string
|
| refined_gold = gt_string
|
| if pred_string.startswith('<table>') and pred_string.endswith('</table>'):
|
| refined_pred = '<html><body>' + pred_string + '</body></html>'
|
| elif not pred_string.startswith('<html><body><table>') and not pred_string.endswith('</table></body></html>'):
|
| refined_pred = '<html><body><table>' + refined_pred + '</table></body></html>'
|
|
|
| if gt_string.startswith('<table>') and gt_string.endswith('</table>'):
|
| refined_gold = '<html><body>' + gt_string + '</body></html>'
|
| elif not gt_string.startswith('<html><body><table>') and not gt_string.endswith('</table></body></html>'):
|
| refined_gold = '<html><body><table>' + refined_gold + '</table></body></html>'
|
|
|
|
|
| for tok in ['<thead>', '</thead>', '<tbody>', '</tbody>']:
|
| refined_pred = refined_pred.replace(tok, '')
|
| refined_gold = refined_gold.replace(tok, '')
|
|
|
| score = evaluator.evaluate(refined_pred, refined_gold)
|
|
|
| return score
|
|
|
| def get_count_tables(data : dict):
|
| table_count = 0
|
| for k,v in data.items():
|
| for elem in v["elements"]:
|
| if elem["category"].lower() == "table":
|
| table_count += 1
|
|
|
| return table_count
|
|
|
| def average_columns(data):
|
| for k,v in data.items():
|
| for elem in v["elements"]:
|
| if elem["category"].lower() == "table":
|
| html = elem["content"]["html"]
|
| soup = BeautifulSoup(html, 'html.parser')
|
| rows = soup.find_all('tr')
|
|
|
| col_counts = [len(row.find_all(['td', 'th'])) for row in rows]
|
|
|
| return sum(col_counts) / len(col_counts) if col_counts else 0
|
|
|
| def evaluate_table(
|
| gt : dict,
|
| pred : dict
|
| ) -> tuple:
|
| """Evaluate the table of the gt against the pred.
|
|
|
| Args:
|
| gt (dict): The gt layout to evaluate.
|
| pred (dict): The pred layout to evaluate against.
|
|
|
| Returns:
|
| tuple(float, float): The TEDS and TEDS-S scores for the table evaluation.
|
| """
|
| gt_count = get_count_tables(gt)
|
| pred_count = get_count_tables(pred)
|
|
|
| gt_cols = average_columns(gt)
|
| pred_cols = average_columns(pred)
|
|
|
| return (gt_cols/pred_cols)*100, (gt_count/pred_count)*100
|
|
|
