Il miglior progetto di previsione delle malattie cardiache nel 2022

Benvenuti in questo tutorial passo passo del nostro progetto di previsione delle malattie cardiache. Qui creerai un modello di apprendimento automatico che prevede se a un paziente può essere diagnosticata una malattia cardiaca o meno.

Dovresti avere familiarità con le basi dell'apprendimento automatico e dell'analisi dei dati per lavorare su questo progetto. Questo progetto richiede che tu abbia familiarità con più algoritmi ML, tra cui Random Forest, K-NN (K-vicino più vicino) e molti altri.

Effettueremo l'analisi dei dati, il filtraggio e testeremo sei diversi algoritmi ML per scoprire quale offre i risultati ottimali per il nostro set di dati. Cominciamo:

L'obiettivo del progetto di previsione delle malattie cardiache

L'obiettivo del nostro progetto di previsione delle malattie cardiache è determinare se a un paziente deve essere diagnosticata una malattia cardiaca o meno, che è un risultato binario, quindi:

Risultato positivo = 1, al paziente verrà diagnosticata una malattia cardiaca.

Risultato negativo = 0, al paziente non verrà diagnosticata una malattia cardiaca.

Dobbiamo trovare quale modello di classificazione ha la maggiore accuratezza e identificare le correlazioni nei nostri dati. Infine, dobbiamo anche determinare quali caratteristiche sono le più influenti nella nostra diagnosi di malattie cardiache.

Caratteristiche

Utilizziamo le seguenti 13 funzioni (X) per determinare il nostro predittore (Y):

1. Età.
2. Sesso: 1 = maschio, 0 = femmina.
3. (cp) tipo di dolore toracico (4 valori – Ordinale), 1° valore: angina tipica, 2° valore: angina atipica, 3° valore: dolore non anginoso, 4° valore: asintomatico.
4. (trestbps) pressione sanguigna a riposo.
5. (col) colesterolo sierico.
6. (Fbs) – glicemia a digiuno > 120 mg/dl.
7. (restecg) – risultati dell'elettrocardiografia a riposo.
8. (talach) – frequenza cardiaca massima raggiunta.
9. (exang) – angina indotta dall'esercizio.
10. (vecchio picco) – Depressione del tratto ST causata dall'esercizio rispetto al riposo.
11. (pendenza) – la pendenza del segmento ST di picco di esercizio.
12. (ca) – il numero dei vasi principali colorati mediante fluoroscopia.
13. (thal) – frequenza cardiaca massima raggiunta (Ordinale), 3 = normale, 6 = difetto fisso, 7 = difetto reversibile.

Passaggio 1: manipolazione dei dati

Per prima cosa esamineremo il set di dati con cui stiamo lavorando convertendolo in un formato più semplice e comprensibile. Ci aiuterebbe a utilizzare i dati in modo più appropriato.

importa numpy come np

importa panda come pd

importa matplotlib come plt

import seaborn come sns

importa matplotlib.pyplot come plt

filePath = '/Utenti/upgrad/Download/datasets-33180-43520-heart.csv'

dati = pd.read_csv(percorsofile)

data.head(5)

Proprio come il codice sopra ci ha aiutato a visualizzare i nostri dati in forma tabellare, utilizzeremo il seguente codice per ulteriori discussioni sui dati:

print(“(Righe, colonne): ” + str(data.shape))

colonne.dati

Il codice sopra mostrerà il numero totale di righe e colonne e i nomi delle colonne nel nostro set di dati. Il numero totale di righe e colonne nei nostri dati è rispettivamente 303 e 14. Ora troveremo il numero di valori univoci per ogni variabile usando la seguente funzione:

data.nunique(asse=0

Allo stesso modo, la seguente funzione riassume la media, il conteggio, la deviazione standard, il minimo e il massimo per le variabili numeriche:

data.descrivi()

Passaggio 2: condurre l'EDA

Ora che abbiamo completato la disputa sui dati, possiamo eseguire l'analisi esplorativa dei dati. Ecco i compiti principali che svolgeremo in questa fase del nostro progetto di previsione delle malattie cardiache:

Trovare correlazioni

Creeremo una matrice di correlazione che ci aiuti a vedere le correlazioni tra le diverse variabili:

corr = data.corr()

plt.subplots(figsize=(15,10))

sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns, annot=True, cmap=sns.diverging_palette(220, 20, as_cmap=True))

sns.heatmap(corr, xticklabels=corr.columns,

yticklabels=corr.colonne,

annot=Vero,

cmap=sns.diverging_palette(220, 20, as_cmap=True))

Per trovare correlazioni immediate tra le caratteristiche, possiamo anche creare pairplot. Useremo piccoli pairplot con solo le variabili continue per approfondire le relazioni:

subData = data[['age','trestbps','chol','thalach','oldpeak']]

sns.pairplot(subData)

Utilizzo di violino e box plot

Con Violin and Box plots possiamo vedere le statistiche di base e la distribuzione dei nostri dati. Puoi usarlo per confrontare la distribuzione di una variabile specifica tra diverse categorie. Ci aiuterà anche a identificare i valori anomali nei dati. Usa il seguente codice:

plt.figure(figsize=(12,8))

sns.violinplot(x= 'target', y= 'oldpeak',hue=”sex”, inner='quartile',data= data )

plt.title("Livello Thalach vs. Malattie cardiache",fontsize=20)

plt.xlabel("Heart Disease Target", fontsize=16)

plt.ylabel("Livello Thalach", fontsize=16)

Nel primo violino e box plot, troviamo che i pazienti positivi hanno una mediana inferiore per la depressione ST rispetto ai pazienti negativi. Quindi, useremo un grafico per confrontare il livello di depressione ST e le malattie cardiache.

plt.figure(figsize=(12,8))

sns.boxplot(x= 'target', y= 'thalach',hue=”sesso”, data=data )

plt.title("Livello di depressione ST vs. malattie cardiache", fontsize=20)

plt.xlabel("Bersaglio cardiovascolare",fontsize=16)

plt.ylabel("Depressione ST indotta dall'esercizio relativo al riposo", fontsize=16)

Qui, i pazienti positivi avevano una mediana più alta per il livello di depressione ST rispetto ai pazienti negativi.

Filtraggio dei dati

Ora filtreremo i dati in base ai pazienti con malattie cardiache positive e negative. Inizieremo con il filtraggio dei dati per pazienti con cardiopatia positiva:

pos_data = data[data['target']==1]

pos_data.descrivi()

Allo stesso modo, filtreremo i dati in base ai pazienti con malattie cardiache negative:

pos_data = data[data['target']==0]

pos_data.descrivi()

Passaggio 3: utilizzo di algoritmi di apprendimento automatico

Preparazione

Qui prepareremo i dati per il training assegnando le caratteristiche a X e l'ultima colonna al predittore Y:

X = data.iloc[:, :-1].valori

Y = data.iloc[:, -1}.valori

Quindi, divideremo i dati in due set, set di allenamento e set di test:

da sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(X,y,test_size = 0.2, random_state = 1)

Infine, normalizzeremo i dati in modo che la sua distribuzione abbia una media di 0:

da sklearn.preprocessing import StandardScaler

sc = StandardScaler()

x_treno = sc.fit_transform(x_treno)

x_test = sc.transform(x_test)

Formazione del modello

In questa sezione, utilizzeremo più algoritmi di apprendimento automatico e troveremo quello che offre la massima precisione:

1° Modello: Regressione Logistica

da sklearn.metrics import classificazione_report

da sklearn.linear_model import LogisticRegression

model1 = LogisticRegression(random_state=1) # ottiene l'istanza del modello

model1.fit(x_treno, y_treno) # Treno/Modello di adattamento

y_pred1 = model1.predict(x_test) # ottieni y previsioni

print(classification_report(y_test, y_pred1)) # accuratezza dell'output

La precisione di questo modello era del 74%.

2° modello: K-NN (K-vicini più vicini)

da sklearn.metrics import classificazione_report

da sklearn.neighbours importa KNeighboursClassifier

model2 = KNeighboursClassifier() # ottiene l'istanza del modello

model2.fit(x_treno, y_treno) # Treno/Modello di adattamento

y_pred2 = model2.predict(x_test) # ottieni y previsioni

print(classification_report(y_test, y_pred2)) # accuratezza dell'output

La precisione di questo modello era del 75%.

3° modello: Support Vector Machine (SVM)

da sklearn.metrics import classificazione_report

da sklearn.svm importa SVC

model3 = SVC(random_state=1) # ottiene l'istanza del modello

model3.fit(x_treno, y_treno) # Treno/Modello di adattamento

y_pred3 = model3.predict(x_test) # ottieni y previsioni

print(classification_report(y_test, y_pred3)) # accuratezza dell'output

La precisione di questo modello era del 75%.

4° Modello: Classificatore Naive Bayes

da sklearn.metrics import classificazione_report

da sklearn.naive_bayes importa GaussianNB

model4 = GaussianNB() # ottiene l'istanza del modello

model4.fit(x_treno, y_treno) # Treno/Modello di adattamento

y_pred4 = model4.predict(x_test) # ottieni y previsioni

print(classification_report(y_test, y_pred4)) # accuratezza dell'output

La precisione di questo modello era del 77%.

5° modello: Foresta casuale

da sklearn.metrics import classificazione_report

da sklearn.ensemble importa RandomForestClassifier

model6 = RandomForestClassifier(random_state=1)# ottiene l'istanza del modello

model6.fit(x_treno, y_treno) # Treno/Modello di adattamento

y_pred6 = model6.predict(x_test) # ottieni y previsioni

print(classification_report(y_test, y_pred6)) # accuratezza dell'output

Questo modello aveva la massima precisione dell'80%.

6° Modello: XGBoost

da xgboost import XGBClassifier

modello7 = XGBClassifier(random_state=1)

model7.fit(x_treno, y_treno)

y_pred7 = model7.predict(x_test)

print(classification_report(y_test, y_pred7))

La precisione di questo modello era del 69%.

Dopo aver testato diversi algoritmi ML, abbiamo scoperto che il migliore era Random Forest in quanto ci ha fornito una precisione ottimale dell'80%.

Tieni presente che qualsiasi percentuale di precisione superiore all'80% è troppo bella per essere vera e potrebbe essere dovuta a un overfitting. Ecco perché l'80% è il numero ottimale da raggiungere.

Passaggio 4: trovare il punteggio delle funzionalità

Qui troveremo il Feature Score, che ci aiuta a prendere decisioni importanti indicandoci quale caratteristica è stata la più utile per il nostro modello:

# ottenere importanza

importanza = model6.feature_importances_

# riepiloga l'importanza della funzione

per i,v in enumerare(importanza):

print('Caratteristica: %0d, Punteggio: %.5f' % (i,v))

Abbiamo scoperto che le prime quattro caratteristiche erano il tipo di dolore toracico (cp), la frequenza cardiaca massima raggiunta (talach), il numero di vasi principali (ca) e la depressione ST causata dall'esercizio rispetto al riposo (oldpeak).

Conclusione

Congratulazioni, ora hai completato con successo il progetto di previsione delle malattie cardiache. Avevamo 13 caratteristiche, di cui abbiamo scoperto che le più importanti erano il tipo di dolore toracico e la frequenza cardiaca massima raggiunta.

Abbiamo testato sei diversi algoritmi ML e abbiamo scoperto che l'algoritmo più accurato era Random Forest. Dovresti testare questo modello con il set di test e vedere come funziona questo modello.

D'altra parte, se vuoi saperne di più sull'apprendimento automatico e sull'intelligenza artificiale, ti consigliamo di dare un'occhiata ai nostri corsi di intelligenza artificiale . Studierai direttamente da esperti del settore e lavorerai su progetti di settore che ti permetteranno di testare le tue conoscenze. Dai un'occhiata se sei interessato a una carriera nell'apprendimento automatico e nell'intelligenza artificiale.

Se sei interessato a saperne di più sull'apprendimento automatico, dai un'occhiata al programma Executive PG di IIIT-B e upGrad in Machine Learning e AI, progettato per i professionisti che lavorano e offre oltre 450 ore di formazione rigorosa, oltre 30 casi di studio e incarichi, IIIT -B Status di Alumni, oltre 5 progetti pratici pratici e assistenza sul lavoro con le migliori aziende.