{'fraction_non_alphanumeric': 0.03297141455036192, 'fraction_numerical': 0.010244141823089192, 'mean_word_length': 4.7332512748373485, 'pattern_counts': {'":': 0, '<': 12, '<?xml version=': 0, '>': 12, 'https://': 2, 'lorem ipsum': 0, 'www.': 1, 'xml': 1}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Simplified DOM Trees for Transferable Attribute Extraction from the Web

There has been a steady need to precisely extract structured knowledge from the web (i.e. HTML documents). Given a web page, extracting a structured object along with various attributes of interest (e.g. price, publisher, author, and genre for a book) can facilitate a variety of downstream applications such as large-scale knowledge base construction, e-commerce product search, and personalized recommendation. Considering each web page is rendered from an HTML DOM tree, existing approaches formulate the problem as a DOM tree node tagging task. However, they either rely on computationally expensive visual feature engineering or are incapable of modeling the relationship among the tree nodes. In this paper, we propose a novel transferable method, Simplified DOM Trees for Attribute Extraction (SimpDOM), to tackle the problem by efficiently retrieving useful context for each node by leveraging the tree structure. We study two challenging experimental settings: (i) intra-vertical few-shot extraction, and (ii) cross-vertical fewshot extraction with out-of-domain knowledge, to evaluate our approach. Extensive experiments on the SWDE public dataset show that SimpDOM outperforms the state-of-the-art (SOTA) method by 1.44% on the F1 score. We also find that utilizing knowledge from a different vertical (cross-vertical extraction) is surprisingly useful and helps beat the SOTA by a further 1.37%.

: Learning a transferable model based on HTML DOM trees to extract attributes from unseen websites of various verticals. Note that every web page is rendered from a Document Object Model (DOM) Tree. All the attributes are located in the leaf nodes of the trees.

INTRODUCTION
As the world wide web explosively grows nowadays, there has been a perennial need to automate the translation of web pages into structured knowledge [6,15]. Attribute extraction systems recognize attributes of interest from web pages. For example, collecting book authors can facilitate the user's faceted search by allowing users to narrow down the search results with a filter on the book's attribute. Attribute extraction as well enables various downstream applications including large-scale knowledge base/graph construction [12,40], e-commerce product search [4,15], and personalized recommendation [39]. However, the semi-structured data format, noisy page contents, and multifarious page layouts all make it a non-trivial task to extract attributes, compared to the unstructured texts, which can be easily modeled as a sequence [24]. Take Figure 1 as an example. The web page on the left-hand-side is a partial screenshot from a bookstore website. The web page is rendered to display in a browser based on the source data, a Document Object Model (DOM) tree [14] (a corresponding subtree is shown in the middle of Figure 1). In this paper, our goal is to extract attributes of interest such as {title, author, isbn13, publisher} from the detail pages of various websites. A detail page denotes a page that corresponds to a single data record [5], like a book in a bookstore or an NBA player on a sports website.
Traditional solutions rely on the fact that many websites are created by templates such as Wrapper Induction [2,19,27]. Some unsupervised methods [7,43] avoid the use of templates and can automatically extract attributes, but neglect the semantics of attribute values. Thus considerable human efforts are required for either periodically updating templates or annotating unseen websites. In this work, we aim to build a novel transferable model to reduce expensive human efforts and to extract attributes from unseen websites of various verticals.
Some recent work [15,25] explores visual patterns of each node such as its bounding box coordinates and surrounding nodes on the web page. However, achieving these features requires a computationally expensive rendering process and extra memory space to save the necessary images, CSS, and JavaScript files that could easily be out-of-date. FreeDOM [21] avoids rendering-based features and models the pairwise node relationship with node-level feature representations that are learned separately. Nevertheless, it is inconvenient to deploy such a two-stage model in practice. The rich DOM tree-level contexts are neglected by this method as well. In this paper, we propose a novel single-stage approach, Simplified DOM Trees for Attribute Extraction (SimpDOM), that does not require visual features, instead relying on a careful construction of the context of a node in the DOM tree that generalizes well to unseen websites in the domain 1 as well as to websites in other domains.
Specifically, SimpDOM builds a rich representation for each node by focusing on its contextual features. Then a node classification is conducted to decide which attribute type it belongs to. For instance in Figure 1, we notice that the closest text node to "J. K. Rowling" contains information "by" which means "J. K. Rowling" is likely to be the author of this book. We also notice important attribute values are usually clustered together to draw readers' attention, like isbn13, publisher, and publication date appear right in the same table. In short, the contexts in a simplified neighborhood can provide website-invariant features such as some semantically informative expressions and vertical-invariant clues such as the co-occurrence of multiple attribute values. We visualize the neighboring relationship of DOM nodes for three websites from two verticals in figure 2. Obviously, the nodes that contain attribute values are always close to each other in the DOM trees.
We consider two challenging experimental scenarios in this paper, (i) intra-vertical few-shot extraction, where we learn a model with a few labeled seed websites and predict on other unseen websites from the same vertical; (ii) cross-vertical few-shot extraction with out-of-domain knowledge, where we train the model with all 1 We use domain and vertical interchangeable in this paper.  the websites from an out-of-domain vertical A, then finetune this model with a few seed sites from vertical B, and finally test it on other unseen websites from vertical B. The first scenario tests the transferability among websites from the same vertical while the second assesses the effectiveness of cross-domain knowledge.
Overall, our paper describes the following contributions: • To the best of our knowledge, this is the first work that efficiently extracts each node's informative contexts from the DOM trees to tackle the attribute extraction task. • We are also the first to study the transferable representations for the cross-vertical few-shot attribute extraction scenario. • Extensive experiments on the public dataset, SWDE [15], show that SimpDOM significantly outperforms the SOTA method by 1.44% on the F1 score, and the out-of-domain knowledge helps beat the SOTA by a further 1.37%.
• We will open-source our implementations to provide a testbed and facilitate future research in this direction.

PROBLEM FORMULATION AND APPROACH
In this section, we formally define the problem and introduce the outline of our proposed method, SimpDOM.

Few-shot attribute extraction from semi-structured websites
We tackle the problem of extracting attributes from unseen semistructured websites. Each vertical has a set of websites. Each website is composed of a collection of detailed pages which share a similar template. Each page has a DOM tree which contains a variable node set and a fixed node set where the text contents are stored, and also a set of non-text nodes . Fixed nodes remain the same across different detailed pages on the same website while variable nodes may contain different contents. Attribute Extraction. The goal of attribute extraction is to extract a possible value for each attribute type from the DOM tree nodes. We narrow down the search range to variable nodes because the attribute values should vary in different detailed pages. We formulate the attribute extraction as a node tagging task. Given a detailed page  with a set of variable nodes , we aim to learn a model to classify each node ∈ into one of the pre-defined vertical-specific types (e.g. title, author, isbn13, publisher) or none representing that this node does not contain any attribute values. We assume that one node can correspond to at most one pre-defined attribute type [15]. Few-shot Intra-vertical Extraction. Given a set of annotated seed websites { 1 , 2 , ..., } from vertical , we aim to learn a transferable model M to extract attributes from a larger set of unseen websites { 1 , 2 , ..., } from the same vertical. Few-shot Cross-vertical Extraction. In this scenario, we leverage a set of annotated out-of-domain websites from vertical 1 to learn a transferable extraction model M and fine-tune the model with seed websites { 1 , 2 , ..., } from vertical 2 . Finally, we extract attributes from unseen websites { 1 , 2 , ..., } of 2 . Figure 3 shows the overall framework of the proposed SimpDOM model for the few-shot attribute extraction task. We firstly simplify the DOM trees to extract context features for each node. All the textual features are then fed into a text encoder to generate a dense semantic embedding. We find that extra discrete features built from markup information such as XPath and leaf node type can result in a better node representation. We also add the relative position of each node as a global feature for the extraction task. The combined node embedding is used for predicting the type of node. In the intra-vertical scenario, we directly apply a multi-class classifier to the node embedding and output the attribute type probability distribution. In the cross-vertical scenario, the attribute sets differ from vertical to vertical. Therefore, we have to alter the inference strategy to binary classification to achieve a matching probability for each attribute type. Then, we select the attribute with the highest probability as the prediction.

NODE ENCODER AND CLASSIFIER
The node encoder consists of three components: DOM tree simplification module, text encoder, and discrete feature module.

DOM Tree Simplification Module
In this module, we simplify the DOM tree to extract the contexts for each variable node , namely its friend circle features, which are composed of the node's partner and friends. The whole DOM tree is a collection of nodes that originate from a unique starting node called the root. The set of nodes on the path from root to node (not including ) are ancestors of node . The friends of denotes a set of text nodes ⊆ ∪ \{ }. For each ∈ , the distances from both and to their lowest common ancestor ∈ should be no more than constant . We compute the distance by counting the number of edges on the path. The partner of is a special friend node for which and are the only two text nodes in the tree that originates from their lowest common ancestor. Note that each node has at most one partner in the DOM tree while it could have zero or multiple friends. Usually, partner is the closest friend to in the DOM tree.
As function F described in Algorithm 1, for each variable node ∈ , we decode its XPath information to record the closest ancestors of . For instance, if the XPath of is "/body/tr/td/", we consider both "/body/tr/" and "/body/" as the ancestor of . Reversely, we can easily obtain all the descendants of each ancestor node to composite the candidate set for retrieving the partner and friends. By limiting the size of , we can narrow down the search area in the tree such that the noisy textual features from distant branches can be efficiently trimmed, as shown in Figure 4.
In the extraction process, we keep all the basic HTML element tags like <tr> and <td> while remove the formatting and style tags such as <strong> and <font> 2 . In Figure 5, we plot a common sub tree structure (a) and its three possible variants (b,c,d). With Algorithm 1, we can simplify and normalize the three variants to (a) in order to extract the friend circle features.
With partner and friends extracted from the DOM tree for each node , we feed the three sets of textual features separately into the text encoder as described in section 3.2 to generate three representations , , and which are all -dimensional vectors. We derive the joint semantic embedding by simply concatenating the three representations as follows: Note that the joint embedding is a 3 -dimensional vector.

Text Encoder
Node contains a sequence of text 1 = [ 1 , 2 , ..., 1 ], where ∈ W and 1 denotes the word sequence length. We can easily split each word into a sequence of characters 2 = [ 1 , 2 , ..., 2 ], where ∈ C and 2 is the character sequence length. W and C are vocabularies of words and characters. We employ a hierarchical LSTM-CNN text encoder to encode the character-level and wordlevel features. 2 We refer to the HTML tag categories in https://www.w3schools.com/TAGS/ref_ byfunc.asp.
Formatting Text Tree Edge Figure 5: Subtree skeletons of web page DOMs including a common structure (a) and its three possible variants (b), (c) and (d). "Basic" denotes a set of basic HTML element tags, while "Formatting" represents some formatting and style tags such as <strong> and <font>. The "Text" node has text information. We aim to simplify all possible variants to (a), in order to efficiently extract the partner (marked as P) and friends (F) for each target node (T).
We notice that the attribute values usually contain useful morphological patterns in the character-level semantics [21]. For example, ( ' ft) and ( -ft) are two common patterns of height attribute in the nbaplayer vertical. Their character-level representation can be very essential. Therefore, we leverage a Convolutional Neural Network to encode the character-level embeddings (dimension ) of each word , resulting in ℎ . We simply concatenate ℎ with its word-level representation retrieved from external pretrained word embeddings: ℎ = ; ℎ . The LSTM [16] has been widely used as the unit of Recurrent Neural Network for learning the latent representation of sequence data [23]. Therefore, we feed the latent word representations ℎ 1 , ℎ 2 , ..., ℎ 1 into a bi-directional LSTM network, resulting in = ℎ ; ℎ . Similarly, we can achieve the semantic representations for the node's partner and friends, and .

Discrete Feature Module
Xpath embeddings. Markup features such as XPath can be very useful for node tagging. An XPath of a DOM node "/html/body/tr/td/" can be seen as a sequence of HTML tags [<html>, <body>, <tr>, <td>]. We learn a separate bi-directional LSTM to get the dense representation ℎ of dimension ℎ for each XPath sequence such that it can make use of all the meaningful tags in the sequence. Leaf node type embeddings. The tag type of the DOM leaf node such as "<h1>" can also be meaningful. "<h1>" means the node is likely to be the title of the page, highly correlating with the name of a nbaplayer or the title of a book. We collect the vocabulary set of the HTML tags and randomly initialize an embedding of dimension for each of them.
Position embeddings. We also leverage the relative position of each node as a discrete feature. This global information can benefit the task. For example in the auto vertical, the model usually lies on the top of the page. We apply depth-first-search to traverse the tree and get the occurrence position of each node. Then we compute its relative position via ⌈ max { } ⌉. Similarly, a random embedding of dimension is initialized for each position. Semantic similarity. We notice the for each node the text in the partner node can help determine 's attribute type and modeling the semantic relation between the text in and the attribute types allows us to best leverage this data. Specifically, we compute the cosine similarity 3 between the partner embedding and each attribute embedding to model their semantic relations, which results in a semantic similarity vector of dimension , where denotes the number of pre-defined attribute types.

Inference and Optimization
Under the intra-vertical scenario, the node embedding is connected to a multi-layer perceptron (MLP) for multi-class classification, as illustrated below: where + 1 denotes the number of pre-defined attribute types plus a none type.
Under the cross-vertical scenario, we notice each vertical has a different attribute set. The MLP layer for multi-class classification can no longer be reused for different verticals which have different sizes of attribute sets. Therefore, we alter the inference strategy to binary classification. We individually concatenate the node embedding to each attribute embedding of dimension which is randomly initialized. We then connect it to a separate MLP and compute a score h for each attribute type: Under both scenarios, we lastly apply the softmax function to normalize h and select the largest as the predictionŷ: The loss function optimizes the cross-entropy between the true labels y and the normalized probabilistic scores p.

EXPERIMENTS
In this section, we firstly introduce the dataset and evaluation metrics. We also explain the implementation details to guarantee the reproducibility of our method. Then, a collection of baseline models are introduced to compare with our model under the intra-vertical few-shot extraction scenario. We also conduct a series of ablation studies to answer the following questions: (i) What are the contributions from each set of features? (ii) Will sequence modeling work well on DOM tree nodes? (iii) What are the performances of using different word embedding strategies? Lastly, we evaluate the effectiveness of the out-of-domain knowledge under the cross-vertical few-shot extraction scenario.

Dataset
We rely on a public data set, SWDE [15] that consists of more than 124,000 web pages from 80 websites of 8 verticals to train and evaluate the proposed model. Detailed statistics are shown in Table 1. Each vertical consists of 10 websites and contains 3 to 5 attributes of interest. We notice book and job have the most variable nodes on average which is roughly three times the nodes in vertical auto and university.  In the intra-vertical few-shot experiments, we follow the settings in FreeDOM [21] to randomly select seed websites as the training data and use the remaining 10 − websites as the test set. Note that in this few-shot extraction task, none of the pages in the 10 − websites have been visited in the training phase. This setting is abstracted from the real application scenario where only a small set of labeled data is provided for specific websites and we aim to infer the attributes on a much larger unseen website set.
In the cross-vertical few-shot experiments, we leverage one vertical as the out-of-domain knowledge to train a model. Then we conduct the same intra-vertical extraction experiments by loading the checkpoints from the pretrained model for parameter initialization. We create this experimental setting to enable a broader knowledge transfer across various verticals, which can tackle the scenario where the domain of the existing annotation is inconsistent with the unseen websites.

Evaluation Metrics
We evaluate the extraction performance by page-level F1 scores, following the evaluation metrics from SWDE and FreeDOM [15,21]. Page-level F1 score is the harmonic mean of extraction precision and recall in each page. Specifically, we evaluate the predicted attribute values with the true values for each detailed page. We compute an average F1 score over all the verticals (Table 2) to compare with the baselines. We also compute the average F1 score for each vertical ( Figure 6) and each attribute (Figure 7) for detailed analysis.

Implementation details
For data pre-processing, we use open-source LXML library 4 to process each page for obtaining the DOM tree structures. Then, we follow the simple heuristic used in [21] to filter nodes whose values are constant in all pages of a website, thus most of the noisy pageinvariant textual nodes such as the footer and navigation contents are removed and the experiments are significantly accelerated in terms of the training speed. We use GloVe pretrained representations [29] to initialize our word embeddings. Other representations such as character embeddings and attribute embeddings are all randomly initialized. We also cut off every node's text when it has more than 15 words. We set both maximum edge number and maximum ancestor number as 5 for extracting friend circle features and only keep the closest 10 friends for each DOM tree node by comparing their relative positions on the web page.
We conduct a grid search for all the hyper-parameters. We use 100 for both word embedding size and character embedding size . We select ℎ , , as 30, 30, 20, respectively. For the CNN network, we use 50 filters and 3 as kernel size. For the LSTM network, we set the hidden layer size as 100. The model is implemented in Tensorflow. We train the model with epoch number 15 and a batch size 32. We apply a dropout mechanism following the MLP layer to avoid over-fitting issues. The dropout rate is 0.3. We use Adam as the optimizer where the learning rate is 0.001. It takes less than 30 minutes to finish the a complete training and evaluation cycle for each vertical with one NVIDIA V100 GPU.

Baseline Models
We compare against several baselines: Stacked Skews Model (SSM). SSM [5] utilizes expensive handcrafted features and tree alignment algorithms to align the unseen web pages with seed web pages. This method does not require visual rendering features, which is the same as our model. Rendering-feature Model (Render-full). Render-full [15] employs visual features to express the distances between node blocks rendered with the web browser. Visual distances are proven a good feature to encode the neighboring relationships among nodes [25] but this method requires the time-consuming rendering process and needs extra memory space to save the images, CSS, and JavaScripts that can easily be out-of-date. In specific, Render-full employs a sophisticated heuristic algorithm to compute the visual distances, which gives the best performance [15], compared to other variants Render-PL and Render-IP. Relational Neural Model (FreeDOM-X). FreeDOM leverages a relational neural network to encode features such as the relative distance and text semantics. This method is composed of two stages. The first stage model (FreeDOM-NL) learns a dense representation for each DOM tree node via node-level classification. The relational neural network in the second stage (FreeDOM-Full) claims to capture the distance and semantic relatedness between pairs of nodes in the DOM trees. This two-stage model does not rely on 4 https://lxml.de/ visual features but is hard to be deployed in practice. Besides, only modeling the relatedness between pairs of nodes neglects the rich structural information in the tree such as the friend circles. We compare with both FreeDOM-NL and FreeDOM-Full because the single-stage FreeDOM-NL is closer to our model and FreeDOM-Full achieves the state-of-the-art experimental results.   Table 2 shows the overall comparisons between our model SimpDOM and all four baselines using different numbers of seed websites. Our model achieves a slightly worse performance when = 1 while largely outperforms Render-Full when = {2, 3, 4, 5}. We can conclude that the delicately crafted visual features can capture more patterns in the scenario where extremely small training data exists. However, they are not as transferable as the rich semantic features extracted from our simplified DOM trees as increases. Our method also consistently outperforms the state-ofthe-art method FreeDOM-Full (an average lift of 1.44% over all the 's) and achieves a 3.47%-10.54% improvement from the single-stage approach, FreeDOM-NL, per F1 score.

Intra-vertical Few-shot Extraction Results
We plot the detailed performance of SimpDOM on different verticals in figure 8. In general, the performance is improved as increases. This is not surprising because more training data obtain better coverage of all possible instances. we also observe that the rate of performance growth slows down and sometimes the F1 scores of some verticals (e.g. nbaplayer and restaurant) even fluctuates as more data join the training process (i.e. as increases). We think the reason is that the model becomes more robust and less new knowledge can be transferred from annotated websites to unseen websites in these verticals.

Ablation Study
In Figure 6, we demonstrate an ablation study on different features of SimpDOM, including discrete features and friend circle features. We find that both sets of features improve the attribute extraction performance dramatically. For instance, the friend circle features lift up the F1 score of nbaplayer vertical from 82.18% to 91.37% and the discrete features increase the performance on book vertical by 8.51%. However, restaurant is a special case where the result drops when we employ either of the two feature sets. We believe the node texts in some attribute values such as name and address are  distinguishable enough and adding more features just brings more noise to the classification. This is also corroborated by Figure 7, which explains the detailed performance change when adding the friend circle features per attribute. We observe that the improvement on height of nbaplayer is significant. The nodes containing height value always share a similar pattern xx-yy 5 with some other nodes on the same page. With the friend circle features, we find that weight is always a friend node of height, which makes height distinguishable from other nodes with similar text patterns. Another interesting ablation study is done with an additional sequence modeling layer 6 which is commonly applied to sequence labeling tasks such as named entity recognition on plain text [20,41]. We first obtain a sequence of node embeddings before the MLP classifier where all the nodes are from one web page. Then a new representation can be achieved from the sequence model for each node. The same classifier is used to predict the attribute type with the updated node representation. As shown in Figure 6 (marked as "w/ Node Sequence Modeling"), the additional sequence modeling layer fails to optimize the node representations for all the verticals especially those with more variable nodes such as nbaplayer and job. We suppose that the information from all other DOM tree nodes can be selectively attended to the current node with such mechanism, which however introduces more noise than useful knowledge. This further proves the importance of utilizing the structures in the simplified DOM trees to eliminate the noise from distant and irrelevant nodes.  We also compare the different embedding approaches for encoding textual features. As shown in Table 3, we conduct experiments to test the randomized word embedding, fixed GloVe word embedding, and trainable GloVe word embedding. In the trainable setting, we can continue to optimize the parameters in the embedding layer which is initialized from GloVe and it gets the best performance. We think a specific "web-language" model can serve the web information extraction tasks better. As contextualized language models develop nowadays, we also try the BERT [11] 7 to generate the contextualized embeddings but it decreases the performance by 9.8%. It is not surprising because the context in each node is very limited 8 and the huge size of parameters (110M in BERT-BASE) for fine-tuning can easily cause an over-fitting problem. 7 We choose BERT without loss of generality. It can be replaced by its alternatives like ELMo [30] or XLNet [42]. 8 On average, each variable node contains only 2-5 words in different verticals. 5% 4% 3% 2% 1% 0% Figure 9: Heatmap denoting the performance lifts per F1 score from the out-of-domain knowledge. In specific, we learn a transferable model with verticals in upper case (columns). Then we finetune the model and predict on the verticals in lower case (rows).

Cross-vertical Few-shot Extraction Results
We plot a heatmap in Figure 9 to denote the performance lifts from the out-of-domain knowledge. In specific, each entry in the heatmap relates to a pair of verticals, where the vertical in the upper case is used as the out-of-domain knowledge while the vertical in the lower case is used to train and test the model. We do not plot the scores in the diagonal because every vertical cannot serve as its out-of-domain resource. One interesting observation is that this heatmap is roughly symmetric with respect to the diagonal, which demonstrates a mutual relationship between pairs of verticals. For instance, job and movie, book and nbaplayer, restaurant and book can all significantly improve the extraction performance for each other, while auto and job, camera and nbaplayer seem to be irrelevant to each other. We show the performance of each vertical achieved by using the most helpful vertical's out-of-domain knowledge in Figure 6. We achieve the highest average F1 score 93% over all the verticals ( = 3).

RELATED WORK 5.1 Web Information Extraction
Web information extraction processes vast amount of unstructured or semi-structured contents from the web and has drawn a lot of attention from the data mining research community [3,6,13,22,31]. Four broad categories of web information extraction tasks can be summarized. They are attribute (entity) extraction, relation extraction, composite extraction, and application-driven extraction. Attribute extraction targets to identify named entity mentions such as book price, phone number, movie title from web documents. Though this task is intuitive to describe, the high-quality corpus annotation requires time-consuming human-crafted rules and dictionaries [5,15,21,28]. Relation extraction associates pairs of named entities and identifies a pre-defined relationship between them. Closed relation extraction defines a closed set of relation types including a special type indicating "no relation" while open relation extraction conducts a binary classification of whether there exists a relationship between the two entities [1,24,25,32,46]. Composite extraction aims to extract more complex concepts such as reviews, opinions, and sentiment mentions. Attribute and relation extractions can be integrated into the high-level workflow of composite extraction with other sub-modules like sentiment classification or aspect detection [8-10, 34, 36]. Application-driven extraction includes a broad spectrum of application scenarios such as web representation learning, PDF information extraction using OCR techniques, anomaly detection of web-based attacks and so on [17,18,26,33,37,45].

Attribute Extraction from Web Documents
Attribute extraction serves as the fundamental task in the web information extraction pipelines and enables a wide range of downstream applications [4,12,39,40]. However, there still exists a huge room to develop attribute extraction methods of high accuracy and strong transferability. Traditional approaches [2,7,19,27,35,43,44] either reply on analyzing the templates that are used to build the web pages or leverage unsupervised models to tackle the problem. However, they neglect the rich semantics of the attribute values and require considerable human efforts for annotations, thus failing to be generalizable to unseen websites. Some recent methods [5,15] believe utilizing visual features generated from the web page rendering process can enable the model to extract attributes from new websites. Nevertheless, it is time-consuming to build visual features and space-unfriendly to store the necessary images, CSS, JavaScript files that are prone to be out-of-date. In this paper, we aim to construct a transferable model to extract attributes from unseen websites without using any visual features.

CONCLUSION
In this paper, we propose a simple but effective method, SimpDOM, that simplifies the DOM trees to extract informative and transferable knowledge for the attribute extraction task. We build a rich representation for each DOM tree node without using any visual features. Extensive experiments show that SimpDOM significantly outperforms the SOTA method by 1.44% on the F1 score and utilizing out-of-domain knowledge further improves the performance by 1.37%. We will open-source the implementations to facilitate further researches in the web data mining community.