Cloud-Based Phrase Mining and Analysis of User-Defined Phrase-Category Association in Biomedical Publications

Summary

We present a protocol and associated programming code as well as metadata samples to support a cloud-based automated identification of phrases-category association representing unique concepts in user selected knowledge domain in biomedical literature. The phrase-category association quantified by this protocol can facilitate in depth analysis in the selected knowledge domain.

Abstract

The rapid accumulation of biomedical textual data has far exceeded the human capacity of manual curation and analysis, necessitating novel text-mining tools to extract biological insights from large volumes of scientific reports. The Context-aware Semantic Online Analytical Processing (CaseOLAP) pipeline, developed in 2016, successfully quantifies user-defined phrase-category relationships through the analysis of textual data. CaseOLAP has many biomedical applications.

We have developed a protocol for a cloud-based environment supporting the end-to-end phrase-mining and analyses platform. Our protocol includes data preprocessing (e.g., downloading, extraction, and parsing text documents), indexing and searching with Elasticsearch, creating a functional document structure called Text-Cube, and quantifying phrase-category relationships using the core CaseOLAP algorithm.

Our data preprocessing generates key-value mappings for all documents involved. The preprocessed data is indexed to carry out a search of documents including entities, which further facilitates the Text-Cube creation and CaseOLAP score calculation. The obtained raw CaseOLAP scores are interpreted using a series of integrative analyses, including dimensionality reduction, clustering, temporal, and geographical analyses. Additionally, the CaseOLAP scores are used to create a graphical database, which enables semantic mapping of the documents.

CaseOLAP defines phrase-category relationships in an accurate (identifies relationships), consistent (highly reproducible), and efficient manner (processes 100,000 words/sec). Following this protocol, users can access a cloud-computing environment to support their own configurations and applications of CaseOLAP. This platform offers enhanced accessibility and empowers the biomedical community with phrase-mining tools for widespread biomedical research applications.

Introduction

Manual evaluation of millions of text files for the study of phrase-category association (e.g., Age group to protein association) is incomparable with the efficiency provided by an automated computational method. We want to introduce the cloud-based Context-aware Semantic Online Analytical Processing (CaseOLAP) platform as a phrase-mining method for automated computation of phrase-category association in the biomedical context.

The CaseOLAP platform, which was first defined in 2016¹, is very efficient compared to the traditional methods of data management and computation because of its functional document management called Text-Cube^2,3,4, which distributes the documents while maintaining underlying hierarchy and neighbourhoods. It has been applied in biomedical research⁵ to study entity-category association. The CaseOLAP platform consists of six major steps including download and extraction of data, parsing, indexing, Text-Cube creation, entity count, and CaseOLAP score calculation; which is the main focus of the protocol (Figure 1, Figure 2, Table 1).

To implement the CaseOLAP algorithm, the user sets up categories of interest (e.g., disease, signs and symptoms, age groups, diagnosis) and entities of interest (e.g., proteins, drugs). One example of a category included in this article is the 'Age Groups', which has 'infant', 'child', 'adolescent', and 'adult' subcategories as cells of the Text-Cube and protein names (synonyms) and abbreviations as entities. Medical Subject Headings (MeSH) are implemented to retrieve publications corresponding to the defined categories (Table 2). MeSH descriptors are organized in a hierarchical tree structure to permit search for publications at varying levels of specificity (a sample shown in Figure 3). The CaseOLAP platform utilizes the data indexing and search functionality for curation of the documents associated with an entity which further facilitate document to entity count mapping and CaseOLAP score calculation.

The details of the CaseOLAP score calculation is available in previous publications^1,5. This score is computed using specific ranking criteria based on underlying Text-Cube document structure. The final score is the product of Integrity, Popularity, and Distinctiveness. Integrity describes whether a representative entity is an integral semantic unit that collectively refers to a meaningful concept. The integrity of the user-defined phrase is taken to be 1.0 because it stands as a standard phrase in the literature. Distinctiveness represents the relative relevance of a phrase in one subset of documents compared to the rest of the other cells. It first calculates the relevance of an entity to a specific cell by comparing the occurrence of the protein name in the target data set and provides a normalized Distinctiveness score. Popularity represents the fact that phrase with a higher popularity score appears more frequently in one subset of documents. Rare protein names in a cell are ranked low, while an increase in their frequency of mention has a diminishing return due to the implementation of the logarithmic function of frequency. Quantitatively measuring these three concepts depends on the (1) term frequency of the entity over a cell and across the cells and (2) number of documents having that entity (document frequency) within the cell and across the cells.

We have studied two representative scenarios using a PubMed dataset and our algorithm. We are interested in how mitochondrial proteins are associated with two unique categories of MeSH descriptors; "Age Groups" and "Nutritional and Metabolic Diseases". Specifically, we retrieved 15,728,250 publications from 20 years publications collected by PubMed (1998 to 2018), among them, 8,123,458 unique abstracts have had full MeSH descriptors. Accordingly, 1,842 human mitochondrial protein names (including abbreviations and synonyms), acquired from UniProt (uniprot.org) as well as from MitoCarta2.0 (http://mitominer.mrc-mbu.cam.ac.uk/release-4.0/begin.do>), are systematically examined. Their associations with these 8,899,019 publications and entities were studied using our protocol; we constructed a Text-Cube and calculated the respective CaseOLAP scores.

Protocol

NOTE: We have developed this protocol based on the Python programming language. To run this program, have Anaconda Python and Git pre-installed on the device. The commands provided in this protocol are based on Unix environment. This protocol provides the detail of downloading data from PubMed (MEDLINE) database, parsing the data, and setting up a cloud computing platform for the phrase mining and quantification of user-defined entity-category association.

1.Getting code and python environment setup

1. Download or clone the code repository from Github (https://github.com/CaseOLAP/caseolap) or by typing ‘git clone https://github.com/CaseOLAP/caseolap.git’ in the terminal window.
2. Navigate to the ‘caseolap’ directory. This is the root directory of the project. Within this directory, the ‘data’ directory will be populated with multiple data sets as you progress through these steps in the protocol. The ‘input’ directory is for user-provided data. The ‘log’ directory has log files for troubleshooting purposes. The ‘result’ directory is where the final results will be stored.
3. Using the terminal window, go to the directory where you cloned our GitHub repository. Create the CaseOLAP environment using the ‘environment.yml’ file by typing ‘conda env create -f environment.yaml’ in the terminal. Then activate the environment by typing ‘source activate caseolap’ in the terminal.

2. Downloading documents

1. Make sure that the FTP address in ‘ftp_configuration.json’ in the config directory is the same as the Annual Baseline or Daily Update Files link address, found in the link (https://www.nlm.nih.gov/databases/download/pubmed_medline.html).
2. To download baseline only or update files only, set ‘true’ in the ‘download_config.json’ file in the ‘config’ directory. By default, it downloads and extracts both baseline and update files. A sample of extracted XML data can be viewed at (https://github.com/CaseOLAP/caseolap-pipelines/blob/master/data/extracted-data-sample.xml)
3. Type ‘python run_download.py’ in the terminal window to download abstracts from the Pubmed database. This will create a directory called ‘ftp.ncbi.nlm.nih.gov’ in the current directory. This process checks the integrity of the downloaded data and extracts it to the target directory.
4. Go to the ‘log’ directory to read the log messages in ‘download_log.txt’ in case the download process fails. If the process is completed successfully, the debugging messages of the download process will be printed out in this log file.
5. When the download is complete, navigate through ‘ftp.ncbi.nlm.nih.gov’ to make sure that there is ‘updatefiles’ or ‘basefiles’ or both directories based on download configuration in ‘download_config.json’. The file statistics become available at ‘filestat.txt’ in the ‘data’ directory.

3. Parsing documents

1. Make sure that downloaded and extracted data is available at ‘ftp.ncbi.nlm.nih.gov’ directory from step 2. This directory is the input data directory in this step.
2. To modify the data-parsing schema, select parameters in ‘parsing_config.json’ file in the ‘config’ directory by setting their value to ‘true’. By default, it parses the PMID, authors, abstract, MeSH, location, journal, publication date.
3. Type ‘python run_parsing.py’ in the terminal to parse the documents from downloaded (or extracted) files. This step parses all downloaded XML files and creates a python dictionary for each document with keys (e.g., PMID, authors, abstract, MeSH of the file based on parsing schema setup at step 3.2).
4. Once data parsing is completed, make sure that parsed data is saved in the file called ‘pubmed.json’ in the data directory. A sample of parsed data is available at Figure 3.
5. Go to the ‘log’ directory to read the log messages in ‘parsing_log.txt’ in case the parsing process fails. If the process is completed successfully, the debugging messages will be printed out in the log file.

4. Mesh to PMID mapping

1. Make sure that parsed data (‘pubmed.json’) is available at the ‘data’ directory.
2. Type ‘python run_mesh2pmid.py’ in the terminal to perform MeSH to PMID mapping. This creates a mapping table where each of the MeSH collects associated PMIDs. A Single PMID may fall under the multiple MeSH terms.
3. Once the mapping is completed, make sure that there is ‘mesh2pmid.json’ in the data directory. A sample of the top 20 mapping statistics is available in Table-2, Figures 4 and 5.
4. Go to the ‘log’ directory to read the log messages in ‘mesh2pmid_mapping_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the mapping will be printed out in this log file.

5. Document indexing

1. Download the Elasticsearch application from https://www.elastic.co. Currently, the download is available at (https://www.elastic.co/downloads/elasticsearch). To download the software in the remote cloud, type ‘wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-x.x.x.tar.gz’ in the terminal. Make sure that ‘x.x.x’ in the above command is replaced by proper version number.
2. Make sure that downloaded ‘elasticsearch-x.x.x.tar.gz’ file appears in the root directory then extract the files by typing ‘tar xvzf elasticsearch-x.x.x.tar.gz’ in the terminal window.
3. Open a new terminal and go to the ElasticSearch bin directory by typing ‘cd Elasticsearch/bin’ in the terminal from the root directory.
4. Start the Elasticsearch server by typing ‘./Elasticsearch’ in the terminal window. Make sure that the server is started without error messages. In case of error on starting Elasticsearch server, follow the instructions at (https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html).
5. Modify the contents in the ‘index_init_config.json’ in ‘config’ directory to set index initiation. By default, it will select all items present.
6. Type ‘python run_index_init.py’ in the terminal to initiate an index-database in the Elasticsearch server. This initializes the index with a set of criteria known as index information (e.g., index name, type name, number of shards, number of replicas). You will see the message mentioning index is successfully created.
7. Select the items in the ‘index_populate_config.json’ in the ‘config’ directory by setting their value to ‘true’. By default, it will select all items present.
8. Make sure that parsed data (‘pubmed.json’) is present in the ‘data’ directory.
9. Type ‘python run_index_populate.py’ in the terminal to populate the index by creating bulk data with two components.A first component is a dictionary with metadata information on the index name, type name, and bulk id (e.g., ‘PMID’). A second component is a data dictionary containing all the information on the tags (e.g., ‘title’,’abstract’,’MeSH’).
10. Go to the ‘log’ directory to read the log messages in ‘indexing_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the indexing will be printed out in the log file.

6. Text-cube creation

1. Download the latest MeSH Tree available at (https://www.nlm.nih.gov/mesh/filelist.html). The current version of the code is using MeSH Tree 2018 as ‘meshtree2018.bin’ in the input directory.
2. Define the categories of interest (e.g., Disease names, Age groups, Gender). A category may include one or more MeSH descriptors (https://meshb-prev.nlm.nih.gov/treeView). Collect MeSH IDs for a category. Save the names of the categories in the file ‘textcube_config.json’ in the config directory (see a sample of the category in ‘Age Group’ in the downloaded version of ‘textcube_config.json’ file).
3. Put the collected categories of MeSH IDs in a line separated by a space. Save the category file as ‘categories.txt’ in the ‘input’ directory (see a sample of ‘Age Group’ MeSH IDs in the downloaded version of ‘categories.txt’ file). This algorithm automatically selects all descendent MeSH descriptors. An example of root nodes and descendants are presented in Figure 4.
4. Make sure that ‘mesh2pmid.json’ is in the ‘data’ directory. If the MeSH Tree has been updated with a different name (e.g., ‘meashtree2019.bin’) in ‘input’ directory, make sure that this is properly represented in the input data path in the ‘run_textube.py’ file.
5. Type ‘python run_textcube.py’ in the terminal to create a document data structure called Text-Cube. This creates a collection of documents (PMIDs) for each category. A single document (PMID) may fall under multiple categories, (see Table 3A, Table 3B, Figure 6A and Figure 7A).
6. Once Text-Cube creation step is completed, make sure that following data files are saved in the ‘data’ directory: (1) a cell to PMID table as “textcube_cell2pmid.json”, (2) a PMID to cell mapping table as “textcube_pmid2cell.json”, (3) a collection of all descendant MeSH terms for a cell as “meshterms_per_cat.json” (4) Text-Cube data statistics as “textcube_stat.txt”.
7. Go to the ‘log’ directory to read the log messages in ‘textcube_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the Text-Cube creation will be printed out in the log file.

7. Entity count

1. Create user-defined entities (e.g., protein names, genes, chemicals). Put one entity and its abbreviations in a single line separated by “|”. Save the entity file as ‘entities.txt’ in the ‘input’ directory. A sample of entities can be found in Table 4.
2. Make sure that Elasticsearch server is running. Otherwise, go to step 5.2 and 5.3 to restart the Elasticsearch server. It is expected to have an indexed database called ‘pubmed’ in your Elasticsearch server which was established in step 5.
3. Make sure that ‘textcube_pmid2cell.json’ is in the ‘data’ directory.
4. Type ‘python run_entitycount.py’ in the terminal to perform Entity Count operation. This searches the documents from the indexed database and counts the entity in each document as well as collects the PMIDs in which entities were found.
5. Once the Entity Count is completed, make sure that the final results are saved as ‘entitycount.txt’ and ‘entityfound_pmid2cell.json’ in the ‘data’ directory.
6. Go to the ‘log’ directory to read the log messages in ‘entitycount_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the Entity Count will be printed out in the log file.

8. Metadata update

1. Make sure that all input data (‘entitycount.txt’, ‘textcube_pmid2cell.json’, ‘entityfound_pmid2cell.txt’) are in the ‘data’ directory. These are the input data for Metadata Update.
2. Type ‘python run_metadata_update.py’ in the terminal to update the metadata. This prepares a collection of metadata (e.g., cell name, associated MeSH, PMIDs) representing each text document in the cell. A sample of Text-Cube metadata is presented in Table 3A and Table 3B.
3. Once the Metadata Update is completed, make sure that ‘metadata_pmid2pcount.json’ and ‘metadata_cell2pmid.json’ files are saved in ‘data’ directory.
4. Go to the ‘log’ directory to read the log messages in ‘metadata_update_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the metadata update will be printed out in the log file.

9. CaseOLAP score calculation

1. Make sure that ‘metadata_pmid2pcount.json’ and ‘metadata_cell2pmid.json’ files are present in the ‘data’ directory. These are the input data for score calculation.
2. Type ‘python run_caseolap_score.py’ in the terminal to perform CaseOLAP score calculation. This calculates the CaseOLAP score of the entities based on user-defined categories. The CaseOLAP score is the product of Integrity, Popularity, and Distinctiveness.
3. Once the score computation is completed, make sure that this saves the results in multiple files (e.g., popularity as ‘pop.csv’, distinctiveness as ‘dist.csv’, CaseOLAP score as ’caseolap.csv’), in the ‘result’ directory. The summary of the CaseOLAP score calculation is also presented in Table 5.
4. Go to the ‘log’ directory to read the log messages in ‘caseolap_score_log.txt’ in case this process fails. If the process is completed successfully, the debugging messages of the CaseOLAP score calculation will be printed out in the log file.

Discussion

We have demonstrated that the CaseOLAP algorithm can create a phrase based quantitative association to a knowledge-based category over large volumes of textual data for extraction of meaningful insights. Following our protocol, one can build the CaseOLAP framework to create a desired Text-Cube and quantify entity-category associations through CaseOLAP score calculation. The obtained raw CaseOLAP scores can be taken to integrative analyses including dimensionality reduction, clustering, temporal and geographical analysis, as well as the creation of a graphical database which enables semantic mapping of the documents.

Applicability of the algorithm. Examples of user-defined entities, other than proteins, could be a list of gene names, drugs, specific signs and symptoms including their abbreviations and synonyms. Furthermore, there are many choices for category selection to facilitate specific user-defined biomedical analyses (e.g., Anatomy [A], Discipline and Occupation [H], Phenomena and Processes [G]). In our two use cases, all scientific publications and their textual data are retrieved from the MEDLINE database using PubMed as the search engine, both managed by the National Library of Medicine. However, the CaseOLAP platform may be applied to other databases of interest containing biomedical documents with textual data such as the FDA Adverse Event Reporting System (FAERS). This is an open database containing information on medical adverse events and medication error reports submitted to FDA. In contrast to MEDLINE and FAERS, databases in hospitals containing electronic health records from patients are not open to the public and are restricted by the Health Insurance Portability and Accountability Act known as HIPAA.

CaseOLAP algorithm has been successfully applied to the different types of data (e.g., news articles)¹. The implementation of this algorithm in biomedical documents has been made in 2018⁵. The requirements for applicability of CaseOLAP algorithm is that each of the documents should be assigned with keywords associated with the concepts (e.g., MeSH descriptors in biomedical publications, keywords in news articles). If keywords are not found, one can apply Autophrase^6,7 to collect top representative phrases and build the entity list before implementing our protocol. Our protocol does not provide the step to perform Autophrase.

Comparison with other algorithms. The concept of using a Data-Cube^8,9,10 and a Text-Cube^2,3,4 has been evolving since 2005 with new advancements to make data mining more applicable. The concept of Online Analytical Processing (OLAP)^{11,12,13,14,15} in data mining and business intelligence goes back to 1993. OLAP, in general, aggregates the information from multiple systems, and stores it in a multi-dimensional format. There are different types of OLAP systems implemented in data mining. For example (1) Hybrid Transaction/Analytical Processing (HTAP)^16,17, (2) Multidimensional OLAP (MOLAP)^18,19-Cube based, and (3) Relational OLAP (ROLAP)²⁰.

Specifically, the CaseOLAP algorithm has been compared with numerous existing algorithms, specifically, with their phrase segmentation enhancements, including TF-IDF+Seg, MCX+Seg, MCX, and SegPhrase. Moreover, RepPhrase (RP, also known as SegPhrase+) has been compared with its own ablation variations, including (1) RP without the Integrity measure incorporated (RP No INT), (2) RP without the Popularity measure incorporated (RP No POP), and (3) RP without the Distinctiveness measure incorporated (RP No DIS). The benchmark results are shown in the study by Fangbo Tao et al.¹.

There are still challenges on data mining which can add additional functionality over saving and retrieving the data from the database. Context-aware semantic Analytical Processing (CaseOLAP) systematically implements the Elasticsearch to build an indexing database of millions of documents (Protocol 5). The Text-Cube is a document structure built over the indexed data with user-provided categories (Protocol 6). This enhances the functionality to the documents within and across the cell of the Text-Cube and allow us to calculate term frequency of the entities over a document and document frequency over a specific cell (Protocol 8). The final CaseOLAP score utilizes these frequency calculations to output a final score (Protocol 9). In 2018, we implemented this algorithm to study ECM proteins and six heart diseases to analyze protein-disease associations. The details of this study can be found in the study by Liem, D.A. et al.⁵. indicating that CaseOLAP could be widely used in the biomedical community exploring a variety of diseases and mechanisms.

Limitations of the algorithm. Phrase mining itself is a technique to manage and retrieve important concepts from textual data. While discovering entity-category association as a mathematical quantity (vector), this technique is unable to figure out the polarity (e.g., positive or negative inclination) of the association. One can build the quantitative summarization of the data utilizing the Text-Cude document structure with assigned entities and categories, but a qualitative concept with microscopic granularities cannot be reached. Some concepts are continuously evolving from past till now. The summarization presented for a specific entity-category association includes all incidences throughout the literature. This may lack the temporal propagation of the innovation. In the future, we plan to address these limitations.

Future Applications. About 90% of the accumulated data in the world is in the unstructured text data. Finding a representative phrase and relation to the entities embedded in the text is a very important task for the implementation of new technologies (e.g., Machine Learning, Information Extraction, Artificial Intelligence). To make the text-data machine readable, data need to be organized in the database over which the next layer of tools could be implemented. In the future, this algorithm can be a crucial step in making data mining more functional for the retrieval of information and the quantification of the entity-category associations.