top of page

Prevedere le Malattie Cardiache con il Machine Learning Python tutorial


In questo articolo, studiamo, in dettaglio, gli iperparametri, il codice e le librerie utilizzati per la previsione delle malattie cardiache utilizzando la regressione logistica sul set di dati delle malattie cardiache.


Prerequisiti :


Prevedere le malattie cardiache con il Machine Learning Python tutorial
Prevedere le malattie cardiache con il Machine Learning Python tutorial


Machine Learning per Prevedere le malattie

L'uso dell'apprendimento automatico nelle operazioni sanitarie può essere estremamente vantaggioso per l'azienda. L'apprendimento automatico è stato creato per gestire set di dati di grandi dimensioni e i file dei pazienti sono esattamente questo: molti punti dati che richiedono un'analisi e un'organizzazione approfondite.


Inoltre, mentre un operatore sanitario e un algoritmo di apprendimento automatico molto probabilmente raggiungeranno la stessa conclusione sulla base dello stesso set di dati, l'utilizzo dell'apprendimento automatico otterrà risultati molto più velocemente, consentendo di iniziare il trattamento prima.


Un altro punto per l'utilizzo delle tecniche di apprendimento automatico nell'assistenza sanitaria è l'eliminazione in una certa misura del coinvolgimento umano, il che riduce la possibilità di errore umano. Ciò riguarda in particolare le attività di automazione dei processi, poiché il lavoro di routine noioso è il luogo in cui gli esseri umani sbagliano di più.


Iniziamo l'esempio con Python sulla previsione delle malattie cardiache.


Partiamo importando le librerie necessarie.



import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns


Numpy : Numpy è una libreria Python open source per la gestione di array n-dimensionali, scritta nel linguaggio di programmazione C. Python è anche scritto nel linguaggio di programmazione C. Il caricamento di Numpy nella memoria consente all'interprete Python di lavorare con l'array computing in modo rapido ed efficiente. Numpy offre l'implementazione di varie funzioni matematiche, routine algebriche e trasformate di Fourier. Numpy supporta diverse tecnologie hardware e informatiche ed è adatto per GPU e calcolo distribuito. Il linguaggio di alto livello utilizzato fornisce facilità d'uso rispetto alle varie funzionalità di Numpy.


Pandas : Pandas è un veloce strumento di analisi dei dati open source basato su Python. I panda consentono varie attività di manipolazione dei dati utilizzando gli oggetti Pandas DataFrame. I diversi metodi Panda utilizzati in questo studio verranno spiegati in dettaglio più avanti.


Matplotlib : Matplotlib è una libreria Python che consente di tracciare grafici di qualità di pubblicazione, grafici statici e interattivi utilizzando Python. I grafici Matplotlib possono essere esportati in vari formati di file, possono funzionare con pacchetti di terze parti e possono essere incorporati nei notebook Jupyter. I metodi Matplotlib utilizzati sono spiegati in dettaglio man mano che li incontriamo.


Seaborn : Seaborn è uno strumento di visualizzazione di dati statistici per Python costruito su Matplotlib. La libreria ci consente di creare visualizzazioni di alta qualità in Python.



Esplorazione e visualizzazione dei dati


Scarica il set di dati

heart_disease_dataset_UCI
.csv
Scarica CSV • 11KB

dataframe = pd.read_csv('heart_disease_dataset_UCI.csv')

Il metodo read_csv della libreria Pandas ci consente di leggere il set di dati sulle malattie cardiache in formato file *.csv (comma-separated value) pubblicato da UCI nel dataframe. L'oggetto DataFrame è la struttura dati principale di Pandas che è una tabella bidimensionale con assi etichettati, lungo le righe e insieme alle colonne. Varie operazioni di manipolazione dei dati possono essere applicate al dataframe Pandas lungo righe e colonne.

dataframe.head(10)

Il metodo Pandas dataframe head(10) ci consente di dare un'occhiata alle prime 10 righe del dataframe. Questo ci aiuta a ottenere una panoramica delle varie colonne e un'idea del tipo e dei valori dei dati archiviati nel dataframe.

dataframe.info()

Il metodo Pandas dataframe info() fornisce informazioni sul numero di voci di riga nel dataframe e sul numero di colonne nel dataframe. Viene inoltre fornito il conteggio delle voci non nulle per colonna, il tipo di dati di ciascuna colonna e l'utilizzo della memoria del frame di dati.

dataframe.isna().sum()

I metodi Pandas dataframe isna().sum() forniscono il conteggio dei valori null in ogni colonna.


dataframe.hist figsize=(12,12))

Il metodo Pandas dataframe hist traccia l'istogramma delle diverse colonne, con dimensioni di fig pari a 12 pollici di larghezza e 12 pollici di altezza.



Ridimensionamento standard

X = dataframe.iloc[:,0:13] 
y = dataframe.iloc[:,13]

Successivamente, dividiamo il nostro dataframe in caratteristiche (X) e variabile di destinazione (y) utilizzando la proprietà dataframe 'iloc' di indicizzazione basata sulla posizione intera. Selezioniamo tutte le righe e le prime 13 colonne come variabile X e tutte le righe e la 14a colonna come variabile target.


X = X.values 
y = y.values

Estraiamo e restituiamo una rappresentazione Numpy dei valori X e y utilizzando la proprietà dei valori dataframe per il nostro studio di apprendimento automatico.


from sklearn.preprocessing import StandardScalerX_std=StandardScaler().fit_transform(X)

Usiamo la libreria scikit-learn (sklearn) per i nostri studi sull'apprendimento automatico. La libreria scikit-learn è una libreria Python open source per l'analisi predittiva dei dati e l'apprendimento automatico ed è basata su Numpy, SciPy e Matplotlib. L'ecosistema SciPy viene utilizzato per il calcolo scientifico e fornisce moduli ottimizzati per l'algebra lineare, il calcolo, i solutori ODE e le trasformazioni Fast Fourier, tra gli altri.


Il modulo di preelaborazione sklearn implementa funzioni come il ridimensionamento, la normalizzazione e la binarizzazione dei dati. StandardScaler standardizza le caratteristiche rendendo la media uguale a zero e la varianza uguale a uno. Il metodo fit_transform() raggiunge il duplice scopo di :

(i) il metodo fit() adattando un algoritmo di ridimensionamento e scoprendo i parametri per il ridimensionamento

(ii) il metodo di trasformazione, dove la trasformazione di ridimensionamento effettiva viene applicata utilizzando i parametri trovati nel metodo fit().


Molti algoritmi di apprendimento automatico sono progettati sulla base del presupposto di aspettarsi dati normalizzati/ridimensionati e il ridimensionamento standard è quindi uno dei metodi che aiutano a migliorare l'accuratezza dei modelli di apprendimento automatico.


Train-Test Split

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X_std,y,test_size=0.25,random_state=40)

La classe sklearn model_selection implementa diverse classi di data splitter (divise in treno e set di test, treno KFold e set di test ecc.), ottimizzatori di iperparametri (cerca su una griglia per trovare iperparametri ottimali) e funzionalità di validazione del modello (valuta le metriche del modello con convalida incrociata ecc.).


NB – La convalida incrociata KFold (K=10) significa dividere il treno in 10 parti. 9 parti vengono utilizzate per l'allenamento mentre l'ultima parte viene utilizzata per i test. Successivamente, un altro set di 9 parti (diverso dal set precedente) viene utilizzato per l'allenamento mentre la parte rimanente viene utilizzata per i test. Questo processo viene ripetuto finché ogni parte non forma un set di prova. La media dei 10 punteggi di precisione su 10 set di test è il KFold cross_val_score.


Il metodo train_test_split della classe sklearn model_selection viene utilizzato per suddividere le nostre funzionalità (X) e gli obiettivi (y) in set di training e test. La dimensione del test = 0,25 specifica che il 25% dei dati deve essere mantenuto nel set di test mentre l'impostazione di random_state = 40 garantisce che l'algoritmo generi lo stesso set di dati di addestramento e test ogni volta che viene eseguito l'algoritmo. Gli algoritmi di apprendimento automatico sono casuali per natura e l'impostazione di un random_state garantisce che i risultati siano riproducibili.


Fitting e previsione del modello

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
lr=LogisticRegression(C=1.0,class_weight='balanced',dual=False,
fit_intercept=True, intercept_scaling=1,max_iter=100,multi_class='auto',
n_jobs=None,penalty='l2',random_state=1234,solver='lbfgs',tol=0.0001,
verbose=0,warm_start=False)
model1=lr.fit(X_train,y_train) 
prediction1=model1.predict(X_test)
cm=confusion_matrix(y_test,prediction1) 
sns.heatmap(cm,annot=True,cmap='winter',linewidths=0.3,
linecolor='black',annot_kws={"size":20})
TP=cm[0][0] 
TN=cm[1][1] 
FN=cm[1][0] 
FP=cm[0][1]
print('Testing Accuracy for Logistic Regression:',(TP+TN)/(TP+TN+FN+FP))

l modulo sklearn.metrics include funzioni di punteggio, metriche delle prestazioni e metriche della distanza, tra le altre. Il metodo confusion_matrix fornisce l'accuratezza della classificazione in un formato a matrice.


34 righe che possono salvare e prevenire tantissime morti causate dalle malattie cardiache



Se vuoi provare anche tu segui questi passaggi:

  1. Vai su https://www.intelligenzaartificialeitalia.net/onlinepythoneditor

  2. Scarica il File Dataset che ti abbiamo messo sopra

  3. Segui le Indicazioni per caricare il file nell'editor

  4. Copia e incolla questo codice nella cella

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

dataframe = pd.read_csv('heart_disease_dataset_UCI.csv')

X = dataframe.iloc[:,0:13] 
y = dataframe.iloc[:,13]

X = X.values 
y = y.values

from sklearn.preprocessing import StandardScaler
X_std=StandardScaler().fit_transform(X)

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X_std,y,test_size=0.25,random_state=40)

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix

lr=LogisticRegression(C=1.0,class_weight='balanced',dual=False,
fit_intercept=True, intercept_scaling=1,max_iter=100,multi_class='auto',
n_jobs=None,penalty='l2',random_state=1234,solver='lbfgs',tol=0.0001,
verbose=0,warm_start=False)
model1=lr.fit(X_train,y_train) 
prediction1=model1.predict(X_test)
cm=confusion_matrix(y_test,prediction1) 

TP=cm[0][0] 
TN=cm[1][1] 
FN=cm[1][0] 
FP=cm[0][1]
print('Testing Accuracy for Logistic Regression:',(TP+TN)/(TP+TN+FN+FP))

5. Premi SHIFT+INVIO oppure premi il bottoncino verde in basso a destra



La classe sklearn linear_model implementa una varietà di modelli lineari come la regressione lineare, la regressione logistica, la regressione Ridge, la regressione lazo ecc. Importiamo la classe LogisticRegression per i nostri studi di classificazione. Viene creata un'istanza di un oggetto LogisticRegression.



Dettagli degli iperparametri

Il parametro C specifica la forza di regolarizzazione. La regolarizzazione implica penalizzare il modello per overfitting. C=1.0 è il valore predefinito per LogisticRegressor nella libreria sklearn.


Il metodo class_weight='balanced' fornisce pesi alle classi. Se non specificato, il peso_classe predefinito è = 1. Peso classe = 'bilanciato' assegna i pesi delle classi utilizzando la formula (n_campioni/(n_classi*np.bin_count(y))). es. se n_campioni =100, n_classi=2 e ci sono 50 campioni appartenenti a ciascuna delle classi 0 e 1, peso_classe = 100/(2*50) = 1

dual = False è preferibile quando n_samples > n_features. la doppia formulazione è implementata solo per il regolarizzatore L2 con solutore liblinear.


NB Il solutore liblinear utilizza l'algoritmo di discesa delle coordinate invece degli algoritmi di discesa del gradiente per trovare i parametri ottimali per il modello di regressione logistica. Ad esempio, negli algoritmi di discesa del gradiente, ottimizziamo tutti i parametri contemporaneamente. Mentre la discesa delle coordinate ottimizza solo un parametro alla volta. Nella discesa delle coordinate, inizializziamo prima il parametro vector (theta = [theta 0 , theta 1 …….. theta n ]). Nell'iterazione kth, solo theta i k viene aggiornato mentre (theta 0 k … theta i-1 k e theta i+1 k-1 …. theta n k-1 ) sono fissi.


fit_intercept = True Il valore predefinito è True. Specifica se è necessario aggiungere una costante alla funzione di decisione.


intercept_scaling = 1 Il valore predefinito è 1. È applicabile solo quando il risolutore è liblinear e fit_intercept = True. [X] diventa [X, intercept_scaling]. Una caratteristica sintetica con valore costante = intercept_scaling viene aggiunta a [X]. L'intercetta diventa, intercetta il ridimensionamento * peso della caratteristica sintetica. Il peso delle caratteristiche sintetiche è modificato dalle regolarizzazioni L1/L2. Per ridurre l'effetto della regolarizzazione sui pesi delle caratteristiche sintetiche, è necessario scegliere un valore di intercept_scaling elevato.

max_iter = 100 (predefinito). Viene preso un numero massimo di iterazioni per far convergere i risolutori.


multi_class = 'ovr', 'multinomiale' o auto (predefinito). auto seleziona 'ovr' cioè problema binario se i dati sono binari o se il risolutore è liblineare. In caso contrario, auto seleziona multinomiale che riduce al minimo la funzione di perdita multinomiale anche quando i dati sono binari.


n_jobs (predefinito = Nessuno). Un certo numero di core della CPU viene utilizzato durante la parallelizzazione dei calcoli per multi_class='ovr'. Nessuno significa che viene utilizzato 1 core. -1 significa che tutti i core vengono utilizzati. Ignorato quando il risolutore è impostato su liblinear.


penalità : specifica la norma della penalità (default = L2).


random_state = imposta lo stato casuale in modo che gli stessi risultati vengano restituiti ogni volta che viene eseguito il modello.


risolutore = la scelta dell'algoritmo di ottimizzazione (default = 'lbfgs')


tol = Tolleranza per i criteri di arresto (default = 1e-4)


verbose = 0 (per sopprimere le informazioni durante l'esecuzione dell'algoritmo)


warm_start = (predefinito = Falso). quando è impostato su True, usa la soluzione del passaggio precedente come inizializzazione per il passaggio attuale. Questo non è applicabile per il risolutore liblinear.


Successivamente, chiamiamo il metodo fit sull'oggetto regressore logistico utilizzando (X_train, y_train) per trovare i parametri del nostro modello di regressione logistica. Chiamiamo il metodo predict sull'oggetto regressore logistico utilizzando X_test e i parametri previsti utilizzando il metodo fit() in precedenza.


Possiamo calcolare la matrice di confusione per misurare l'accuratezza del modello utilizzando i valori previsti e y_test.


I parametri per la heatmap sns (seaborn) sono stati spiegati in precedenza. Il parametro linecolor specifica il colore delle linee che divideranno ciascuna cella. Il parametro annot_kws passa gli argomenti delle parole chiave al metodo matplotlib, in questo caso fontsize.


Infine, calcoliamo l'accuratezza del nostro modello di regressione logistica utilizzando la matrice di confusione (Vero Positivo + Vero Negativo)/a Numero totale di campioni di prova = 89,47%.

Conclusione

Questo ci porta alla fine dell'articolo. In questo articolo, abbiamo sviluppato un modello di regressione logistica per la previsione delle malattie cardiache utilizzando un set di dati dal repository UCI.


Ci siamo concentrati sull'acquisizione di una comprensione approfondita degli iperparametri, delle librerie e del codice utilizzati durante la definizione di un modello di regressione logistica attraverso la libreria scikit-learn.


Vuoi mettere in pratica quello che hai letto ?


Oppure segui i tutorial correlati :





Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif
PCR.gif
PCR (5).gif
3.gif
Vediamo se riesci a cliccarmi ! Nascondo una Sorpresa... (2).png

Ciao 

🤗 Articoli consigliati dalla nostra
Intelligenza Artificiale in base ai tuoi interessi

Correlazione Alta

Correlazione Media

Correlazione Bassa

Iscriviti

VUOI DIVENTARE UN MEMBRO DI INTELLIGENZA ARTIFICIALE ITALIA GRATUITAMENTE E TRARNE I SEGUENTI BENEFICI?

Corsi Gratis

più di 150 lezioni online

Dataset Gratis

più di 150o dataset

Ebook Gratis

più di 10 libri da leggere

Editor Gratis

un editor python online

Progetti Gratis

più di 25 progetti python

App Gratis

4 servizi web con I.A.

Unisciti Ora a oltre
1.000.000
di lettori e appassionanti d'I.A.

Tutto ciò che riguarda l'intelligenza Artificiale, in unico posto, in italiano e gratis.

MEGLIO DI COSI' NON SI PUO' FARE

Dopo l'iscrizione riceverai diversi Regali

VUOI SCRIVERE ARTICOLI INSIEME A NOI.

Grazie

bottom of page