Analizza i dati clinici utilizzando BigQuery e AI Platform Notebooks

1. Introduzione

Ultimo aggiornamento: 2022-9-22

Questo codelab implementa un pattern per accedere e analizzare i dati sanitari aggregati in BigQuery utilizzando BigQueryUI e AI Platform Notebooks. Illustra l'esplorazione dei dati di grandi set di dati sanitari utilizzando strumenti familiari come Pandas, Matplotlib ecc. in Notebooks AI Platform conformi a HIPPA. Il "trucco" devi eseguire la prima parte dell'aggregazione in BigQuery, recuperare un set di dati Pandas e quindi lavorare localmente con il set di dati Pandas più piccolo. AI Platform Notebooks fornisce un'esperienza Jupyter gestita, quindi non devi eseguire personalmente i server di blocchi note. AI Platform Notebooks è ben integrato con altri servizi Google Cloud come Big Query e Cloud Storage, il che semplifica e velocizza l'avvio del percorso di analisi dei dati e ML su Google Cloud Platform.

In questo lab di codice imparerai a:

• Sviluppa e testa le query SQL utilizzando la UI di BigQuery.
• Crea e avvia un'istanza di AI Platform Notebooks in Google Cloud.
• Esegui query SQL dal blocco note e archivia i risultati in DataFrame Panda.
• Creare tabelle e grafici utilizzando Matplotlib.
• Esegui il commit del blocco note ed eseguine il push in un Repository di codice sorgente Cloud in Google Cloud.

Cosa ti serve per eseguire questo codelab?

• Devi accedere a un progetto Google Cloud.
• Devi avere un ruolo di Proprietario per il progetto Google Cloud.
• È necessario un set di dati sanitari in BigQuery.

Se non disponi di un progetto Google Cloud, segui questi passaggi per crearne uno.

Nota: questo codelab utilizza AI Platform Notebooks conformi alla normativa HIPAA.

2. Configurazione del progetto

Per questo codelab, utilizzeremo un set di dati esistente in BigQuery (hcls-testing-data.fhir_20k_patients_analytics). Questo set di dati è precompilato con dati sanitari sintetici.

Ottieni l'accesso al set di dati sintetico

1. Dall'indirizzo email che utilizzi per accedere alla console Cloud, invia un'email all'indirizzo [e-mail] richiedendo di partecipare.
2. Riceverai un'email con istruzioni su come confermare l'azione.
3. Utilizza l'opzione per rispondere all'email per unirti al gruppo. NON fare clic sul pulsante .
4. Una volta ricevuta l'email di conferma, potrai procedere al passaggio successivo nel codelab.

Blocca il progetto

1. Nella console di Google Cloud, seleziona il progetto, poi vai a BigQuery.
2. Fai clic sul menu a discesa +AGGIUNGI DATI e seleziona "Blocca un progetto" > "Inserisci il nome del progetto" di Google.

3. Inserisci il nome del progetto "hcls-testing-data" e fai clic su PIN. Il set di dati di test BigQuery "fhir_20k_patients_analytics" disponibili per l'uso.

Nota: se vuoi creare il tuo set di dati, fai riferimento al codelab da FHIR a BigQuery.

3. Sviluppa query utilizzando la UI di BigQuery

Impostazione UI BigQuery

1. Accedi alla console BigQuery selezionando BigQuery dal menu Google Cloud nell'angolo in alto a sinistra ("hamburger").
2. Nella console BigQuery, fai clic su Altro → Impostazioni query e assicurati che il menu SQL precedente NON sia selezionato (Utilizzeremo SQL standard).

Crea query

Nella finestra dell'editor di query, digita la seguente query e fai clic su "Esegui" per eseguirla. Quindi, visualizza i risultati nella finestra "Risultati delle query".

Nota: i blocchi di codice forniti in questa sezione utilizzano il set di dati BQ hcls-testing-data.fhir_20k_patients_analytics. Sostituiscilo se hai deciso di utilizzare il tuo set di dati.

PAZIENTI DI QUERY

#standardSQL - Query Patients
SELECT
  id AS patient_id,
  name[safe_offset(0)].given AS given_name,
  name[safe_offset(0)].family AS family,
  telecom[safe_offset(0)].value AS phone,
  birthDate AS birth_date,
  deceased.dateTime AS deceased_datetime,
  Gender AS fhir_gender_code,
  Address[safe_offset(0)].line AS address1_line_1,
  Address[safe_offset(0)].city AS address1_city,
  Address[safe_offset(0)].state AS address1_state,
  Address[safe_offset(0)].postalCode AS address1_postalCode,
  Address[safe_offset(0)].country AS address1_country
FROM 
  `hcls-testing-data.fhir_20k_patients_analytics.Patient` AS Patient 
LIMIT 10

Query in "Editor query" e risultati:

Nota:i risultati delle query in questa sezione potrebbero essere limitati da righe/colonne per una migliore visibilità. I risultati effettivi potrebbero includere più dati.

PRACTITORI DI QUERY

#standardSQL - Query Practitioners
SELECT 
  id AS practitioner_id, 
  name[safe_offset(0)].given AS given_name,
  name[safe_offset(0)].family AS family_name, 
  gender 
FROM 
  `hcls-testing-data.fhir_20k_patients_analytics.Practitioner` 
LIMIT 10

Risultati della query:

ORGANIZZAZIONE QUERY

Modifica l'ID organizzazione in modo che corrisponda al set di dati.

#standardSQL - Query Organization
SELECT
  id AS org_id,
  type[safe_offset(0)].text AS org_type,
  name AS org_name,
  address[safe_offset(0)].line AS org_addr,
  address[safe_offset(0)].city AS org_addr_city,
  address[safe_offset(0)].state AS org_addr_state,
  address[safe_offset(0)].postalCode AS org_addr_postalCode,
  address[safe_offset(0)].country AS org_addr_country
FROM 
  `hcls-testing-data.fhir_20k_patients_analytics.Organization` AS Organization
WHERE 
  id = "b81688f5-bd0e-3c99-963f-860d3e90ab5d"

Risultati della query:

INCONTRI A QUERY PER PAZIENTE

#standardSQL - Query Encounters by Patient
SELECT
  id AS encounter_id,
  period.start AS encounter_start,
  period.end AS encounter_end,
  status AS encounter_status,
  class.code AS encounter_type,
  subject.patientId as patient_id,
  participant[safe_OFFSET(0)].individual.practitionerId as parctitioner_id,
  serviceProvider.organizationId as encounter_location_id,
  type[safe_OFFSET(0)].text AS encounter_reason
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Encounter` AS Encounter
WHERE
  subject.patientId = "900820eb-4166-4981-ae2d-b183a064ac18"
ORDER BY
  encounter_end

Risultati della query:

RICEVI DURATA MEDIA DEGLI INCONTRI PER TIPO DI INCONTRO

#standardSQL - Get Average length of Encounters by Encounter type 
SELECT
  class.code encounter_class,
  ROUND(AVG(TIMESTAMP_DIFF(TIMESTAMP(period.end),    TIMESTAMP(period.start), HOUR)),1) as avg_minutes
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Encounter` AS Encounter
WHERE
  period.end >= period.start
GROUP BY
  1
ORDER BY
  2 DESC

Risultati della query:

OTTIENI TUTTI I PAZIENTI CHE HANNO TASSO DI A1C >= 6,5

# Query Patients who have A1C rate >= 6.5
SELECT 
  id AS observation_id,
  subject.patientId AS patient_id,
  context.encounterId AS encounter_id,
  value.quantity.value,
  value.quantity.unit,
  code.coding[safe_offset(0)].code,
  code.coding[safe_offset(0)].display AS description
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Observation` 
WHERE 
  code.text like '%A1c/Hemoglobin%' AND 
  value.quantity.value >= 6.5 AND 
  status = 'final'

Risultati della query:

4. Crea un'istanza di AI Platform Notebooks

Segui le istruzioni in questo link per creare una nuova istanza AI Platform Notebooks (JupyterLab).

Assicurati di abilitare l'API Compute Engine.

Puoi scegliere " Crea un nuovo blocco note con opzioni predefinite" o " Crea un nuovo blocco note e specifica le tue opzioni".

5. Crea un blocco note per l'analisi dei dati

Apri l'istanza di AI Platform Notebooks

In questa sezione creeremo e codificheremo un nuovo blocco note Jupyter da zero.

1. Per aprire un'istanza di blocco note, vai alla pagina AI Platform Notebooks nella console di Google Cloud Platform. VAI ALLA PAGINA AI NOTEBOOK DI AI PLATFORM
2. Seleziona Apri JupyterLab per l'istanza che vuoi aprire.

3. AI Platform Notebooks ti indirizza a un URL per la tua istanza di blocco note.

Crea un blocco note

1. In JupyterLab, vai a File -> Nuovo -> Blocco note e seleziona il kernel "Python 3" nel popup o seleziona "Python 3" nella sezione Blocco note nella finestra Avvio app per creare un Untitled.ipynbnotebook.

2. Fai clic con il pulsante destro del mouse su Untitled.ipynb e rinomina il blocco note in "fhir_data_from_bigquery.ipynb". Fai doppio clic per aprirlo, crea le query e salva il blocco note.
3. Puoi scaricare un blocco note facendo clic con il pulsante destro del mouse sul file *.ipynb e selezionando Scarica dal menu.

4. Puoi anche caricare un blocco note esistente facendo clic sulla "Freccia su" .

Crea ed esegui ogni blocco di codice nel blocco note

Copia ed esegui uno alla volta ogni blocco di codice fornito in questa sezione. Per eseguire il codice, fai clic su "Esegui" (Triangolo).

Nota: i blocchi di codice forniti in questa sezione utilizzano il set di dati BQ hcls-testing-data.fhir_20k_patients_analytics. Sostituiscilo se hai deciso di utilizzare il tuo set di dati.

Visualizza la durata del soggiorno per le interazioni in ore

from google.cloud import bigquery

client = bigquery.Client()

lengthofstay="""
SELECT
    class.code as encounter_class,
    period.start as start_timestamp,
    period.end as end_timestamp, 
    TIMESTAMP_DIFF(TIMESTAMP(period.end), TIMESTAMP(period.start), HOUR) 
        as length_of_stay_in_hours
FROM 
    `hcls-testing-data.fhir_20k_patients_analytics.Encounter`
WHERE
    period.end >= period.start
ORDER BY
    4 DESC
LIMIT 10
"""
df = client.query(lengthofstay).to_dataframe()
df.head()

Output del codice e dell'esecuzione:

Nota:gli output di esecuzione in questa sezione potrebbero essere limitati da righe/colonne per una migliore visibilità. I risultati effettivi potrebbero includere più dati.

Ottieni osservazioni - Valori del colesterolo

observation="""
SELECT
  cc.code loinc_code,
  cc.display loinc_name,
  approx_quantiles(round(o.value.quantity.value,1),4) as quantiles,
  count(*) as num_obs
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Observation` o, o.code.coding cc
WHERE
  cc.system like '%loinc%' and lower(cc.display) like '%cholesterol%'
GROUP BY 1,2
ORDER BY 4 desc
"""
df2 = client.query(observation).to_dataframe()
df2.head()

Output esecuzione:

Ottieni quantili di incontri approssimativi

encounters="""
SELECT
  encounter_class,
  APPROX_QUANTILES(num_encounters, 4) num_encounters_quantiles
FROM (
  SELECT
    class.code encounter_class,
    subject.reference patient_id,
    COUNT(DISTINCT id) AS num_encounters
  FROM
    `hcls-testing-data.fhir_20k_patients_analytics.Encounter`
  GROUP BY
    1,2
  )
GROUP BY 1
ORDER BY 1
"""
df3 = client.query(encounters).to_dataframe()
df3.head()

Output esecuzione:

Ottieni la durata media degli incontri in minuti

avgstay="""
SELECT
  class.code encounter_class,
  ROUND(AVG(TIMESTAMP_DIFF(TIMESTAMP(period.end), TIMESTAMP(period.start), MINUTE)),1) as avg_minutes
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Encounter`
WHERE
  period.end >= period.start
GROUP BY
  1
ORDER BY
  2 DESC
  """
df4 = client.query(avgstay).to_dataframe()
df4.head()

Output esecuzione:

Ricevi incontri per paziente

patientencounters="""
SELECT
  id AS encounter_id,
  period.start AS encounter_start,
  period.end AS encounter_end,
  status AS encounter_status,
  class.code AS encounter_type,
  subject.patientId as patient_id,
  participant[safe_OFFSET(0)].individual.practitionerId as parctitioner_id,
  serviceProvider.organizationId as encounter_location_id,
  type[safe_OFFSET(0)].text AS encounter_reason
FROM
  `hcls-testing-data.fhir_20k_patients_analytics.Encounter` AS Encounter
WHERE
  subject.patientId = "900820eb-4166-4981-ae2d-b183a064ac18"
ORDER BY
  encounter_end
"""

df5 = client.query(patientencounters).to_dataframe()
df5.head()

Output esecuzione:

Ottieni organizzazioni

orgs="""
SELECT
  id AS org_id,
  type[safe_offset(0)].text AS org_type,
  name AS org_name,
  address[safe_offset(0)].line AS org_addr,
  address[safe_offset(0)].city AS org_addr_city,
  address[safe_offset(0)].state AS org_addr_state,
  address[safe_offset(0)].postalCode AS org_addr_postalCode,
  address[safe_offset(0)].country AS org_addr_country
FROM 
  `hcls-testing-data.fhir_20k_patients_analytics.Organization` AS Organization
WHERE 
  id = "b81688f5-bd0e-3c99-963f-860d3e90ab5d"
"""

df6 = client.query(orgs).to_dataframe()
df6.head()

Risultato dell'esecuzione:

Recupero pazienti

patients="""
SELECT
  id AS patient_id,
  name[safe_offset(0)].given AS given_name,
  name[safe_offset(0)].family AS family,
  telecom[safe_offset(0)].value AS phone,
  birthDate AS birth_date,
  deceased.dateTime AS deceased_datetime,
  Gender AS fhir_gender_code,
  Address[safe_offset(0)].line AS address1_line_1,
  Address[safe_offset(0)].city AS address1_city,
  Address[safe_offset(0)].state AS address1_state,
  Address[safe_offset(0)].postalCode AS address1_postalCode,
  Address[safe_offset(0)].country AS address1_country
FROM 
  `hcls-testing-data.fhir_20k_patients_analytics.Patient` AS Patient 
LIMIT 10
"""

df7 = client.query(patients).to_dataframe()
df7.head()

Risultati dell'esecuzione:

6. Creare grafici e grafici in AI Platform Notebooks

Esegui le celle di codice nel blocco note "fhir_data_from_bigquery.ipynb" per tracciare un grafico a barre.

Ad esempio, puoi ottenere la durata media degli incontri in minuti.

df4.plot(kind='bar', x='encounter_class', y='avg_minutes');

Risultati del codice e dell'esecuzione:

7. Esegui il commit del blocco note nel repository di codice sorgente Cloud

1. Nella console di Google Cloud, vai a Source Repositories. Se è la prima volta che lo utilizzi, fai clic su Inizia, quindi su Crea repository.

2. Per un momento successivo, vai su Google Cloud -> Cloud Source Repositories e fai clic su + Aggiungi repository per creare un nuovo repository.

3. Seleziona "Crea un nuovo repository", poi fai clic su Continua.
4. Fornisci il nome del repository e del progetto, quindi fai clic su Crea.

Nota: qui e più avanti in tutti i comandi relativi a Repository useremo il nome "my-ai-notebooks". Nel caso tu voglia modificarlo, tieni presente che dovrai farlo in tutti i comandi correlati al repository più avanti in questa sezione.

5. Seleziona "Clona il tuo repository in un repository Git locale", quindi seleziona Credenziali generate manualmente.
6. Segui il passaggio 1 "Genera e archivia le credenziali Git". istruzioni (vedi di seguito). Copia lo script visualizzato sullo schermo.

7. Avvia la sessione del terminale in Jupyter.

8. Incolla tutti i comandi da "Configura Git" finestra sul terminale Jupyter.
9. Copia il percorso di clonazione del repository dai repository di origine Google Cloud Cloud (passaggio 2 nello screenshot di seguito).

10. Incolla questo comando nel terminale JupiterLab. Il comando sarà simile al seguente:

git clone https://source.developers.google.com/p/<your -project-name>/r/my-ai-notebooks

11. "my-ai-notebooks" viene creata in Jupyterlab.

12. Sposta il tuo blocco note (fhir_data_from_bigquery.ipynb) nella cartella "my-ai-notebooks".
13. Nel terminale Jupyter, cambia la directory in "cd my-ai-notebooks".
14. Esegui temporaneamente le modifiche utilizzando il terminale Jupyter. In alternativa, puoi utilizzare l'interfaccia utente di Jupyter (fai clic con il tasto destro del mouse sui file nell'area Non tracciati, seleziona Traccia, quindi i file vengono spostati nell'area Tracciati e viceversa. L'area modificata contiene i file modificati).

git remote add my-ai-notebooks https://source.developers.google.com/p/<your -project-name>/r/my-ai-notebooks

15. Esegui il commit delle modifiche utilizzando il terminale Jupyter o l'interfaccia utente Jupyter (digita il messaggio, quindi fai clic sul pulsante "Selezionato").

git commit -m "message goes here"

16. Esegui il push delle modifiche nel repository remoto utilizzando il terminale Jupyter o l'interfaccia utente di Jupyter (fai clic sull'icona "Esegui il push delle modifiche applicate" ).

git push --all

17. Nella console di Google Cloud, vai a Source Repositories. Fai clic su my-ai-notebooks. Nota che "fhir_data_from_bigquery.ipynb" viene salvato nel repository di codice sorgente Google Cloud.

8. Esegui la pulizia

Per evitare che al tuo account Google Cloud Platform vengano addebitati costi relativi alle risorse utilizzate in questo codelab, al termine del tutorial puoi eseguire la pulizia delle risorse che hai creato su Google Cloud, in modo che non occupino la tua quota e che non ti vengano addebitati costi in futuro. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Eliminazione del set di dati BigQuery

Segui queste istruzioni per eliminare il set di dati BigQuery che hai creato nell'ambito di questo tutorial. In alternativa, accedi alla console BigQuery, annulla il PIN del progetto hcls-testing-data,se hai utilizzato il set di dati di test fhir_20k_patients_analytics.

Arresto dell'istanza di AI Platform Notebooks

Segui le istruzioni riportate in questo link Arresta un'istanza di blocco note | AI Platform Notebooks per arrestare un'istanza di AI Platform Notebooks.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per questo tutorial, quando lo elimini, elimini anche qualsiasi altro lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato il progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se prevedi di esplorare più tutorial e guide rapide, il riutilizzo dei progetti può aiutarti a evitare di superare i limiti di quota.

1. Nella console Google Cloud, vai alla pagina Progetti. VAI ALLA PAGINA PROGETTI
2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare e fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

9. Complimenti

Complimenti, hai completato il codelab per accedere, eseguire query e analizzare i dati sanitari in formato FHIR utilizzando BigQuery e AI Platform Notebooks.

Hai eseguito l'accesso a un set di dati BigQuery pubblico in Google Cloud.

Hai sviluppato e testato le query SQL utilizzando la UI di BigQuery.

Hai creato e avviato un'istanza di AI Platform Notebooks.

Hai eseguito query SQL in JupyterLab e archiviato i risultati della query in Pandas DataFrame.

Hai creato grafici e diagrammi utilizzando Matplotlib.

Hai eseguito il commit e il push del blocco note in un repository di codice sorgente Cloud in Google Cloud.

Ora conosci i passaggi chiave necessari per iniziare il tuo percorso di analisi dei dati sanitari con BigQuery e AI Platform Notebooks su Google Cloud.

©Google, Inc. e/o le sue società consociate. Tutti i diritti riservati. Distribuzione vietata.