COVID-19 Open Research Dataset

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 forskningsgrupper 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 virusfamiljen för virus som ska användas av den globala forskningsgruppen.

Den här datamängden gör att forskare kan utnyttja de senaste framstegen inom bearbetning av naturligt språk för att generera nya insikter som stöd för strid mot den här sjukdomsförseningar.

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

Anteckning

Microsoft tillhandahåller Azure Open Datasets på "i sin"-basis. Microsoft ger inga garantier, uttryckliga eller underförstådda, avseende din användning av datamängderna. 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 direkta skador, följdskador, särskilda, indirekta, oförutsedda eller oförutsedda skador, till följd av din användning av datamängderna.

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 Institute. 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 licensinformation finns på PMC-webbplatsen, medRxiv-webbplatsenoch 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 ska du citera 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 med över 50 000 akademiska artiklar – inklusive över 40 000 med fulltext – om COVID-19, SARS-CoV-2 och relaterade virus från virus. Den här datamängden 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-datorn är två gånger:

  1. Visa hur du kommer åt CORD-19-datauppsättningen på Azure: Vi ansluter till Azure Blob Storage-kontot som innehåller CORD-19-datauppsättningen.
  2. Gå igenom datamängdens struktur: Artiklar i datamängden lagras som json-filer. Vi tillhandahåller exempel som visar:
  • Hitta artiklarna (navigera i containern)
  • Läsa artiklarna (navigera i json-schemat)

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

  • Azure Storage (till exempel pip install azure-storage )
  • NLTK (docs)
  • 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 blob-tjä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 som använder BlockBlobService API:erna. Mer information finns här:

CORD-19-data lagras i covid19temp containern. 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 rubrik, författare, sammanfattning och (där det är tillgängligt) fulltextdata lagras.

Använda metadata.csv

Datamängden CORD-19 levereras med – en enda fil som registrerar grundläggande information om alla artiklar som är tillgängliga i metadata.csv CORD-19-datamängden. 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å vi ska använda lite polska.

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äs fullständig text

metadata.csv innehåller inte själva texten. 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)

Nu kan vi 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 av body_text , 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 Parse

I exemplet ovan har vi tittat 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 has_pmc_xml_parse == True följande format för fall:

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

Ett 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 genom blobar direkt

I exemplen ovan använde vi filen för att navigera i data, konstruera metadata.csv blobfilsökvägen och läsa data från bloben. Ett alternativ är 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. Vi kan 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 satts ihop 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

Layout för containern

Här använder vi ett enkelt regex för att utforska filstrukturen för containern om detta 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 Open Datasets katalogen.