COVID-19 Open Research Dataset

  • Artikel

Datasamling med vetenskapliga fulltextartiklar och metadata om COVID-19 och coronaviruset som optimerats för maskinläsning och gjorts tillgängliga för forskning globalt.

Som svar på covid-19-pandemin har Allen Institute for AI samarbetat med ledande forskargrupper för att förbereda och distribuera COVID-19 Open Research Dataset (CORD-19). Den här datamängden är en kostnadsfri resurs med över 47 000 vetenskapliga artiklar, inklusive över 36 000 med fulltext, om COVID-19 och coronavirusfamiljen av virus för användning av den globala forskningsgemenskapen.

Denna datamängd mobiliserar forskare att tillämpa de senaste framstegen inom bearbetning av naturligt språk för att generera nya insikter till stöd för kampen mot denna infektionssjukdom.

Korpusen kan komma att uppdateras när ny forskning publiceras i peer-granskade tidskrifter och arkiveringstjänster såsom bioRxiv, medRxiv med flera.

Kommentar

Microsoft tillhandahåller Azure Open Datasets i befintligt fall. Microsoft ger inga garantier, uttryckliga eller underförstådda garantier eller villkor för din användning av datauppsättningarna. I den utsträckning som tillåts enligt din lokala lag frånsäger sig Microsoft allt ansvar för eventuella skador eller förluster, inklusive direkt, följdriktig, särskild, indirekt, tillfällig eller straffbar, till följd av din användning av datauppsättningarna.

Datamängden tillhandahålls enligt de ursprungliga villkor som gällde när Microsoft tog emot källdatan. Datamängden kan innehålla data från Microsoft.

Licensvillkor

Den här datamängden görs tillgänglig av Allen Institute of AI och Semantic Scholar. Genom att få åtkomst till, ladda ned eller på annat sätt använda något av det innehåll som tillhandahålls i CORD-19-datasamlingen godkänner du den datasamlingslicens som gäller användningen av denna datasamling. Specifik licensieringsinformation för enskilda artiklar i den här datasamlingen är tillgängliga i metadatafilen. Mer licensieringsinformation finns på PMC-webbplatsen, medRxiv-webbplatsen och bioRxiv-webbplatsen.

Volym och kvarhållning

Den här datamängden lagras i JSON-format och den senaste versionen innehåller över 36 000 fulltextartiklar. Varje rapport utgör ett enskilt JSON-objekt. Visa schemat.

Lagringsplats

Datamängden lagras i Azure-regionen Östra USA. Att hitta beräkningsresurser i USA, östra rekommenderas för tillhörighet.

Hänvisning

När du inkluderar CORD-19-data i en publikation eller omdistribution anger du datauppsättningen på följande sätt:

I bibliografin:

COVID-19 Open Research Dataset (CORD-19). 2020. Version YYYY-MM-DD. Retrieved from COVID-19 Open Research Dataset (CORD-19). Accessed YYYY-MM-DD. doi:10.5281/zenodo.3715505

I text: (CORD-19, 2020)

Kontakt

Om du har frågor om den här datamängden är du välkommen att kontakta partnerships@allenai.org.

Dataåtkomst

Azure Notebooks

CORD-19-datauppsättningen

CORD-19 är en samling av över 50 000 vetenskapliga artiklar - inklusive över 40 000 med fulltext - om COVID-19, SARS-CoV-2 och relaterade coronavirus. Denna datamängd har gjorts fritt tillgänglig med målet att hjälpa forskningsgrupper att bekämpa COVID-19-pandemin.

Målet med den här notebook-filen är tvådelat:

  1. Visa hur du kommer åt CORD-19-datauppsättningen i Azure: Vi ansluter till Azure Blob Storage-kontot som rymmer CORD-19-datauppsättningen.
  2. Gå igenom strukturen för datauppsättningen: Artiklar i datamängden lagras som json-filer. Vi tillhandahåller exempel som visar:
  • Så här hittar du artiklarna (navigerar i containern)
  • Läsa artiklarna (navigera i json-schemat)

Beroenden: Den här notebook-filen kräver följande bibliotek:

  • Azure Storage (till exempel pip install azure-storage)
  • NLTK (dokument)
  • Pandas (till exempel pip install pandas)

Hämta CORD-19-data från Azure

CORD-19-data har laddats upp som en Azure Open Dataset här. Vi skapar en blobtjänst som är länkad till den här öppna CORD-19-datauppsättningen.

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,
)

Vi kan använda den här blobtjänsten som referens för data. Vi kan navigera i datauppsättningen och använda API:erna BlockBlobService . Mer information finns här:

CORD-19-data lagras i containern covid19temp . Det här är filstrukturen i containern tillsammans med en exempelfil.

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
        ...

Varje .json-fil motsvarar en enskild artikel i datauppsättningen. Det är här som rubriken, författarna, sammanfattningen och (där det är tillgängligt) lagras fulltextdata.

Använda metadata.csv

CORD-19-datauppsättningen levereras med metadata.csv – en enda fil som registrerar grundläggande information om alla papper som är tillgängliga i CORD-19-datauppsättningen. Det här är ett bra ställe att börja utforska!

# 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)

Det är mycket att ta in vid första anblicken, så låt oss applicera lite polering.

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

Exempel: Läsa fulltext

metadata.csv innehåller inte själva fulltexten. Nu ska vi se ett exempel på hur du läser det. Leta upp och packa upp json i fulltext och konvertera den till en lista med meningar.

# 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)

Vi kan nu läsa json-innehållet som är associerat med den här bloben på följande sätt.

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()))

I det här exemplet är vi intresserade body_textav , som lagrar textdata på följande sätt:

"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"
    },
    ...
]

Det fullständiga json-schemat finns här.

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])

PDF jämfört med PMC XML-parsning

I exemplet ovan tittade vi på ett ärende med has_pdf_parse == True. I så fall var blobfilsökvägen i formuläret:

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

Du kan också använda följande format för fall med has_pmc_xml_parse == True :

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

Till exempel:

# 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).

Iterera direkt via blobar

I exemplen ovan använde metadata.csv vi filen för att navigera i data, konstruera blobfilsökvägen och läsa data från bloben. Ett alternativ är att iterera genom själva blobarna.

# 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)

Nu kan vi iterera genom blobarna direkt. Låt oss till exempel räkna antalet json-filer som är tillgängliga.

# 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

Bilaga

Problem med datakvalitet

Det här är en stor datamängd som av uppenbara skäl har sammanställts ganska hastigt! Här följer några problem med datakvaliteten som vi har observerat.

Flera shas

Vi observerar att det i vissa fall finns flera shas för en viss post.

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

Containerns layout

Här använder vi en enkel regex för att utforska containerns filstruktur om den uppdateras i framtiden.

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

Nästa steg

Visa resten av datauppsättningarna i katalogen Öppna datamängder.