Set di dati per la ricerca aperta sul COVID-19

Set di dati CORD-19

CORD-19 è una raccolta di oltre 50.000 articoli accademici, tra cui oltre 40.000 con testo completo, riguardo al COVID-19, SARS-CoV-2 e coronavirus correlati. Questo set di dati è stato reso disponibile gratuitamente con l'obiettivo di aiutare le comunità di ricerca a combattere la pandemia di COVID-19.

L'obiettivo di questo notebook è duplice:

1. Illustrare come accedere al set di dati CORD-19 in Azure: ci si connette all'account di archiviazione BLOB di Azure che ospita il set di dati CORD-19.
2. Illustrare dettagliatamente la struttura del set di dati: gli articoli nel set di dati vengono archiviati come file JSON. Vengono forniti esempi che illustrano:

• Come trovare gli articoli (esplorazione del contenitore)
• Come leggere gli articoli (esplorazione dello schema JSON)

Dipendenze. Questo notebook richiede le librerie seguenti:

• Risorsa di archiviazione di Azure, ad esempio, pip install azure-storage-blob
• Toolkit per il linguaggio naturale o NLTK (documentazione)
• Pandas, ad esempio, pip install pandas

Recuperare i dati CORD-19 da Azure

I dati CORD-19 sono stati caricati come set di dati aperti di Azure qui. Viene creato un servizio BLOB collegato a questo set di dati aperti CORD-19.

from azure.storage.blob import BlockBlobService

# storage account details
azure_storage_account_name = "azureopendatastorage"
azure_storage_sas_token = "sv=2019-02-02&ss=bfqt&srt=sco&sp=rlcup&se=2025-04-14T00:21:16Z&st=2020-04-13T16:21:16Z&spr=https&sig=JgwLYbdGruHxRYTpr5dxfJqobKbhGap8WUtKFadcivQ%3D"

# create a blob service
blob_service = BlockBlobService(
    account_name=azure_storage_account_name,
    sas_token=azure_storage_sas_token,
)

È possibile usare questo servizio BLOB come handle sui dati. È possibile esplorare il set di dati usando le API BlockBlobService. Per altri dettagli, vedere qui:

• Concetti relativi al servizio BLOB
• Operazioni sui contenitori

I dati CORD-19 vengono archiviati nel contenitore covid19temp. Si tratta della struttura di file all'interno del contenitore insieme a un file di esempio.

metadata.csv
custom_license/
    pdf_json/
        0001418189999fea7f7cbe3e82703d71c85a6fe5.json        # filename is sha-hash
        ...
    pmc_json/
        PMC1065028.xml.json                                  # filename is the PMC ID
        ...
noncomm_use_subset/
    pdf_json/
        0036b28fddf7e93da0970303672934ea2f9944e7.json
        ...
    pmc_json/
        PMC1616946.xml.json
        ...
comm_use_subset/
    pdf_json/
        000b7d1517ceebb34e1e3e817695b6de03e2fa78.json
        ...
    pmc_json/
        PMC1054884.xml.json
        ...
biorxiv_medrxiv/                                             # note: there is no pmc_json subdir
    pdf_json/
        0015023cc06b5362d332b3baf348d11567ca2fbb.json
        ...

Ogni file JSON corrisponde a un singolo articolo nel set di dati. È la posizione in cui titolo, autori, sommario e, dove disponibile, i dati del testo completo vengono archiviati.

Uso di metadata.csv

Il set di dati CORD-19 include metadata.csv, un singolo file che registra informazioni di base su tutti i documenti disponibili nel set di dati CORD-19. Questa è un’ottima posizione da cui iniziare a esplorare!

# container housing CORD-19 data
container_name = "covid19temp"

# download metadata.csv
metadata_filename = 'metadata.csv'
blob_service.get_blob_to_path(
    container_name=container_name,
    blob_name=metadata_filename,
    file_path=metadata_filename
)

import pandas as pd

# read metadata.csv into a dataframe
metadata_filename = 'metadata.csv'
metadata = pd.read_csv(metadata_filename)

metadata.head(3)

Ci sono molte informazioni da comprendere a prima vista quindi è consigliabile applicare dei filtri.

simple_schema = ['cord_uid', 'source_x', 'title', 'abstract', 'authors', 'full_text_file', 'url']

def make_clickable(address):
    '''Make the url clickable'''
    return '<a href="{0}">{0}</a>'.format(address)

def preview(text):
    '''Show only a preview of the text data.'''
    return text[:30] + '...'

format_ = {'title': preview, 'abstract': preview, 'authors': preview, 'url': make_clickable}

metadata[simple_schema].head().style.format(format_)

# let's take a quick look around
num_entries = len(metadata)
print("There are {} many entries in this dataset:".format(num_entries))

metadata_with_text = metadata[metadata['full_text_file'].isna() == False]
with_full_text = len(metadata_with_text)
print("-- {} have full text entries".format(with_full_text))

with_doi = metadata['doi'].count()
print("-- {} have DOIs".format(with_doi))

with_pmcid = metadata['pmcid'].count()
print("-- {} have PubMed Central (PMC) ids".format(with_pmcid))

with_microsoft_id = metadata['Microsoft Academic Paper ID'].count()
print("-- {} have Microsoft Academic paper ids".format(with_microsoft_id))

There are 51078 many entries in this dataset:
-- 42511 have full text entries
-- 47741 have DOIs
-- 41082 have PubMed Central (PMC) ids
-- 964 have Microsoft Academic paper ids

Ad esempio: leggere il testo completo

metadata.csv non contiene il testo completo. Vedere un esempio su come leggerlo. Individuare e decomprimere il file JSON di testo completo e convertirlo in un elenco di frasi.

# choose a random example with pdf parse available
metadata_with_pdf_parse = metadata[metadata['has_pdf_parse']]
example_entry = metadata_with_pdf_parse.iloc[42]

# construct path to blob containing full text
blob_name = '{0}/pdf_json/{1}.json'.format(example_entry['full_text_file'], example_entry['sha'])  # note the repetition in the path
print("Full text blob for this entry:")
print(blob_name)

È ora possibile leggere il contenuto JSON associato a questo BLOB come indicato di seguito.

import json
blob_as_json_string = blob_service.get_blob_to_text(container_name=container_name, blob_name=blob_name)
data = json.loads(blob_as_json_string.content)

# in addition to the body text, the metadata is also stored within the individual json files
print("Keys within data:", ', '.join(data.keys()))

Ai fini di questo esempio, la parte di interesse è body_text, che archivia i dati di testo come indicato di seguito:

"body_text": [                      # list of paragraphs in full body
    {
        "text": <str>,
        "cite_spans": [             # list of character indices of inline citations
                                    # e.g. citation "[7]" occurs at positions 151-154 in "text"
                                    #      linked to bibliography entry BIBREF3
            {
                "start": 151,
                "end": 154,
                "text": "[7]",
                "ref_id": "BIBREF3"
            },
            ...
        ],
        "ref_spans": <list of dicts similar to cite_spans>,     # e.g. inline reference to "Table 1"
        "section": "Abstract"
    },
    ...
]

Lo schema JSON completo è disponibile qui.

from nltk.tokenize import sent_tokenize

# the text itself lives under 'body_text'
text = data['body_text']

# many NLP tasks play nicely with a list of sentences
sentences = []
for paragraph in text:
    sentences.extend(sent_tokenize(paragraph['text']))

print("An example sentence:", sentences[0])

Analisi XML PDF rispetto al modello di PMC

Nell'esempio precedente è stato esaminato un caso con has_pdf_parse == True. In tal caso, il percorso del file BLOB era del formato:

'<full_text_file>/pdf_json/<sha>.json'

In alternativa, per i casi con has_pmc_xml_parse == True, usare il formato seguente:

'<full_text_file>/pmc_json/<pmcid>.xml.json'

Ad esempio:

# choose a random example with pmc parse available
metadata_with_pmc_parse = metadata[metadata['has_pmc_xml_parse']]
example_entry = metadata_with_pmc_parse.iloc[42]

# construct path to blob containing full text
blob_name = '{0}/pmc_json/{1}.xml.json'.format(example_entry['full_text_file'], example_entry['pmcid'])  # note the repetition in the path
print("Full text blob for this entry:")
print(blob_name)

blob_as_json_string = blob_service.get_blob_to_text(container_name=container_name, blob_name=blob_name)
data = json.loads(blob_as_json_string.content)

# the text itself lives under 'body_text'
text = data['body_text']

# many NLP tasks play nicely with a list of sentences
sentences = []
for paragraph in text:
    sentences.extend(sent_tokenize(paragraph['text']))

print("An example sentence:", sentences[0])

Full text blob for this entry:
custom_license/pmc_json/PMC546170.xml.json
An example sentence: Double-stranded small interfering RNA (siRNA) molecules have drawn much attention since it was unambiguously shown that they mediate potent gene knock-down in a variety of mammalian cells (1).

Eseguire l'iterazione direttamente tra i BLOB

Negli esempi precedenti è stato usato il file metadata.csv per esplorare i dati, costruire il percorso file BLOB e leggere i dati dal BLOB. Un'alternativa è l'iterazione tramite i BLOB stessi.

# get and sort list of available blobs
blobs = blob_service.list_blobs(container_name)
sorted_blobs = sorted(list(blobs), key=lambda e: e.name, reverse=True)

Ora è possibile eseguire l'iterazione direttamente tra i BLOB. Ad esempio, contare il numero di file JSON disponibili.

# we can now iterate directly though the blobs
count = 0
for blob in sorted_blobs:
    if blob.name[-5:] == ".json":
        count += 1
print("There are {} many json files".format(count))

There are 59784 many json files

Appendice

Problemi di qualità dei dati

Il CORD-19 è un set di dati di grandi dimensioni che, per ovvi motivi, è stato messo insieme piuttosto in fretta! Ecco alcuni problemi di qualità dei dati osservati.

Più SHA

In alcuni casi sono presenti più SHA per una determinata voce.

metadata_multiple_shas = metadata[metadata['sha'].str.len() > 40]

print("There are {} many entries with multiple shas".format(len(metadata_multiple_shas)))

metadata_multiple_shas.head(3)

There are 1999 many entries with multiple shas

Layout del contenitore

In questo caso viene usata una semplice espressione regolare per esplorare la struttura dei file del contenitore nel caso in cui venga aggiornata in futuro.

container_name = "covid19temp"
blobs = blob_service.list_blobs(container_name)
sorted_blobs = sorted(list(blobs), key=lambda e: e.name, reverse=True)

import re
dirs = {}

pattern = '([\w]+)\/([\w]+)\/([\w.]+).json'
for blob in sorted_blobs:
    
    m = re.match(pattern, blob.name)
    
    if m:
        dir_ = m[1] + '/' + m[2]
        
        if dir_ in dirs:
            dirs[dir_] += 1
        else:
            dirs[dir_] = 1
        
dirs

Set di dati CORD-19

CORD-19 è una raccolta di oltre 50.000 articoli accademici, tra cui oltre 40.000 con testo completo, riguardo al COVID-19, SARS-CoV-2 e coronavirus correlati. Questo set di dati è stato reso disponibile gratuitamente con l'obiettivo di aiutare le comunità di ricerca a combattere la pandemia di COVID-19.

L'obiettivo di questo notebook è duplice:

1. Illustrare come accedere al set di dati CORD-19 in Azure: viene usato il set di dati AzureML per fornire un contesto per i dati CORD-19.
2. Illustrare dettagliatamente la struttura del set di dati: gli articoli nel set di dati vengono archiviati come file JSON. Vengono forniti esempi che illustrano:

• Come trovare gli articoli (esplorazione della struttura di directory)
• Come leggere gli articoli (esplorazione dello schema JSON)

Dipendenze. Questo notebook richiede le librerie seguenti:

• Software Development Kit Python di AzureML, ad esempio, pip install --upgrade azureml-sdk
• Pandas, ad esempio, pip install pandas
• Toolkit per il linguaggio naturale o NLTK (documentazione), ad esempio, pip install nltk

Se l’NLTK non dispone del pacchetto punkt, è necessario eseguire:

import nltk
nltk.download('punkt')

Recuperare i dati CORD-19 da Azure

I dati CORD-19 sono stati caricati come set di dati aperti di Azure qui. In questo notebook viene usato il set di dati di AzureML per fare riferimento al set di dati aperto CORD-19.

import azureml.core
print("Azure ML SDK Version: ", azureml.core.VERSION)

from azureml.core import  Dataset
cord19_dataset = Dataset.File.from_files('https://azureopendatastorage.blob.core.windows.net/covid19temp')
mount = cord19_dataset.mount()

Il metodo mount() crea una gestione del contesto per il montaggio dei flussi del file system definiti dal set di dati come file locali.

Usare mount.start() e mount.stop() o, in alternativa, usare with mount(): per gestire il contesto.

Il montaggio è supportato solo nei sistemi operativi Unix o come Unix e libfuse deve essere presente. Se l’esecuzione si verifica all'interno di un contenitore Docker, questo deve essere avviato con il flag --privileged o avviato con --cap-add SYS_ADMIN --device /dev/fuse. Per altre informazioni, vedere la documentazione

import os

COVID_DIR = '/covid19temp'
path = mount.mount_point + COVID_DIR

with mount:
    print(os.listdir(path))

['antiviral_with_properties_compressed.sdf', 'biorxiv_medrxiv', 'biorxiv_medrxiv_compressed.tar.gz', 'comm_use_subset', 'comm_use_subset_compressed.tar.gz', 'custom_license', 'custom_license_compressed.tar.gz', 'metadata.csv', 'noncomm_use_subset', 'noncomm_use_subset_compressed.tar.gz']

Questa è la struttura dei file all'interno del set di dati CORD-19, insieme a un file di esempio.

metadata.csv
custom_license/
    pdf_json/
        0001418189999fea7f7cbe3e82703d71c85a6fe5.json        # filename is sha-hash
        ...
    pmc_json/
        PMC1065028.xml.json                                  # filename is the PMC ID
        ...
noncomm_use_subset/
    pdf_json/
        0036b28fddf7e93da0970303672934ea2f9944e7.json
        ...
    pmc_json/
        PMC1616946.xml.json
        ...
comm_use_subset/
    pdf_json/
        000b7d1517ceebb34e1e3e817695b6de03e2fa78.json
        ...
    pmc_json/
        PMC1054884.xml.json
        ...
biorxiv_medrxiv/                                             # note: there is no pmc_json subdir
    pdf_json/
        0015023cc06b5362d332b3baf348d11567ca2fbb.json
        ...

Ogni file JSON corrisponde a un singolo articolo nel set di dati. È la posizione in cui titolo, autori, sommario e, dove disponibile, i dati del testo completo vengono archiviati.

Uso di metadata.csv

Il set di dati CORD-19 include metadata.csv, un singolo file che registra informazioni di base su tutti i documenti disponibili nel set di dati CORD-19. Questa è un’ottima posizione da cui iniziare a esplorare!

import pandas as pd

# create mount context
mount.start()

# specify path to metadata.csv
COVID_DIR = 'covid19temp'
metadata_filename = '{}/{}/{}'.format(mount.mount_point, COVID_DIR, 'metadata.csv')

# read metadata
metadata = pd.read_csv(metadata_filename)
metadata.head(3)

simple_schema = ['cord_uid', 'source_x', 'title', 'abstract', 'authors', 'full_text_file', 'url']

def make_clickable(address):
    '''Make the url clickable'''
    return '<a href="{0}">{0}</a>'.format(address)

def preview(text):
    '''Show only a preview of the text data.'''
    return text[:30] + '...'

format_ = {'title': preview, 'abstract': preview, 'authors': preview, 'url': make_clickable}

metadata[simple_schema].head().style.format(format_)

# let's take a quick look around
num_entries = len(metadata)
print("There are {} many entries in this dataset:".format(num_entries))

metadata_with_text = metadata[metadata['full_text_file'].isna() == False]
with_full_text = len(metadata_with_text)
print("-- {} have full text entries".format(with_full_text))

with_doi = metadata['doi'].count()
print("-- {} have DOIs".format(with_doi))

with_pmcid = metadata['pmcid'].count()
print("-- {} have PubMed Central (PMC) ids".format(with_pmcid))

with_microsoft_id = metadata['Microsoft Academic Paper ID'].count()
print("-- {} have Microsoft Academic paper ids".format(with_microsoft_id))

Ad esempio: leggere il testo completo

metadata.csv non contiene il testo completo. Vedere un esempio su come leggerlo. Individuare e decomprimere il file JSON di testo completo e convertirlo in un elenco di frasi.

# choose a random example with pdf parse available
metadata_with_pdf_parse = metadata[metadata['has_pdf_parse']]
example_entry = metadata_with_pdf_parse.iloc[42]

# construct path to blob containing full text
filepath = '{0}/{1}/pdf_json/{2}.json'.format(path, example_entry['full_text_file'], example_entry['sha'])
print("Full text filepath:")
print(filepath)

È ora possibile leggere il contenuto JSON associato a questo file come indicato di seguito.

import json

try:
    with open(filepath, 'r') as f:
        data = json.load(f)
except FileNotFoundError as e:
    # in case the mount context has been closed
    mount.start()
    with open(filepath, 'r') as f:
        data = json.load(f)
        
# in addition to the body text, the metadata is also stored within the individual json files
print("Keys within data:", ', '.join(data.keys()))

Keys within data: paper_id, metadata, abstract, body_text, bib_entries, ref_entries, back_matter

Ai fini di questo esempio, la parte di interesse è body_text, che archivia i dati di testo come indicato di seguito:

"body_text": [                      # list of paragraphs in full body
    {
        "text": <str>,
        "cite_spans": [             # list of character indices of inline citations
                                    # e.g. citation "[7]" occurs at positions 151-154 in "text"
                                    #      linked to bibliography entry BIBREF3
            {
                "start": 151,
                "end": 154,
                "text": "[7]",
                "ref_id": "BIBREF3"
            },
            ...
        ],
        "ref_spans": <list of dicts similar to cite_spans>,     # e.g. inline reference to "Table 1"
        "section": "Abstract"
    },
    ...
]

Visualizzare lo schema JSON completo.

from nltk.tokenize import sent_tokenize
# the text itself lives under 'body_text'
text = data['body_text']

# many NLP tasks play nicely with a list of sentences
sentences = []
for paragraph in text:
    sentences.extend(sent_tokenize(paragraph['text']))

print("An example sentence:", sentences[0])

Analisi XML PDF rispetto al modello di PMC

Nell'esempio precedente è stato esaminato un caso con has_pdf_parse == True. In tal caso, il percorso file era del formato:

'<full_text_file>/pdf_json/<sha>.json'

In alternativa, per i casi con has_pmc_xml_parse == True, usare il formato seguente:

'<full_text_file>/pmc_json/<pmcid>.xml.json'

Ad esempio:

# choose a random example with pmc parse available
metadata_with_pmc_parse = metadata[metadata['has_pmc_xml_parse']]
example_entry = metadata_with_pmc_parse.iloc[42]

# construct path to blob containing full text
filename = '{0}/pmc_json/{1}.xml.json'.format(example_entry['full_text_file'], example_entry['pmcid'])  # note the repetition in the path
print("Path to file: {}\n".format(filename))

with open(mount.mount_point + '/' + COVID_DIR + '/' + filename, 'r') as f:
    data = json.load(f)

# the text itself lives under 'body_text'
text = data['body_text']

# many NLP tasks play nicely with a list of sentences
sentences = []
for paragraph in text:
    sentences.extend(sent_tokenize(paragraph['text']))

print("An example sentence:", sentences[0])

Appendice

Problemi di qualità dei dati

Il CORD-19 è un set di dati di grandi dimensioni che, per ovvi motivi, è stato messo insieme piuttosto in fretta! Ecco alcuni problemi di qualità dei dati osservati.

metadata_multiple_shas = metadata[metadata['sha'].str.len() > 40]

print("There are {} many entries with multiple shas".format(len(metadata_multiple_shas)))

metadata_multiple_shas.head(3)