Meilleur projet de prédiction des maladies cardiaques en 2022

Bienvenue dans ce didacticiel étape par étape de notre projet de prédiction des maladies cardiaques. Ici, vous allez créer un modèle d'apprentissage automatique qui prédit si un patient peut être diagnostiqué avec une maladie cardiaque ou non.

Vous devez être familiarisé avec les bases de l'apprentissage automatique et de l'analyse de données pour travailler sur ce projet. Ce projet nécessite que vous soyez familiarisé avec plusieurs algorithmes ML, notamment Random Forest, K-NN (K-plus proche voisin) et bien d'autres.

Nous effectuerons le traitement des données, le filtrage et testerons six algorithmes ML différents pour trouver celui qui offre les résultats optimaux pour notre ensemble de données. Commençons:

L'objectif du projet de prédiction des maladies cardiaques

L'objectif de notre projet de prédiction des maladies cardiaques est de déterminer si un patient doit être diagnostiqué avec une maladie cardiaque ou non, ce qui est un résultat binaire, donc :

Résultat positif = 1, le patient recevra un diagnostic de maladie cardiaque.

Résultat négatif = 0, le patient ne sera pas diagnostiqué avec une maladie cardiaque.

Nous devons trouver quel modèle de classification a la plus grande précision et identifier les corrélations dans nos données. Enfin, nous devons également déterminer quelles caractéristiques sont les plus influentes dans notre diagnostic de maladie cardiaque.

Caractéristiques

Nous utilisons les 13 caractéristiques suivantes (X) pour déterminer notre prédicteur (Y) :

1. Âge.
2. Sexe : 1 = Masculin, 0 = Féminin.
3. (cp) type de douleur thoracique (4 valeurs – Ordinal), 1ère valeur : angine typique, 2ème valeur : angine atypique, 3ème valeur : douleur non angineuse, 4ème valeur : asymptomatique.
4. (trestbps) tension artérielle au repos.
5. (chol) cholestérol sérique.
6. (Fbs) – glycémie à jeun > 120 mg/dl.
7. (restecg) – résultats d'électrocardiographie au repos.
8. (thalach) – fréquence cardiaque maximale atteinte.
9. (exang) - angine induite par l'exercice.
10. (oldpeak) - Dépression ST causée par l'exercice par rapport au repos.
11. (pente) - la pente du segment ST d'exercice maximal.
12. (ca) – le nombre de gros vaisseaux colorés par fluoroscopie.
13. (thal) – fréquence cardiaque maximale atteinte (Ordinal), 3 = normal, 6 = défaut fixe, 7 = défaut réversible.

Étape 1 : Analyse des données

Nous allons d'abord examiner le jeu de données avec lequel nous travaillons en le convertissant dans un format plus simple et plus compréhensible. Cela nous aiderait à mieux utiliser les données.

importer numpy en tant que np

importer des pandas en tant que pd

importer matplotlib en tant que plt

importer seaborn en tant que sns

importer matplotlib.pyplot en tant que plt

filePath = '/Users/upgrad/Downloads/datasets-33180-43520-heart.csv'

données = pd.read_csv(filePath)

data.head(5)

Tout comme le code ci-dessus nous a aidés à afficher nos données sous forme de tableau, nous utiliserons le code suivant pour un traitement ultérieur des données :

print(“(Lignes, colonnes): ” + str(data.shape))

données.colonnes

Le code ci-dessus affichera le nombre total de lignes et de colonnes et les noms de colonnes dans notre ensemble de données. Le nombre total de lignes et de colonnes dans nos données est respectivement de 303 et 14. Nous allons maintenant trouver le nombre de valeurs uniques pour chaque variable en utilisant la fonction suivante :

data.nunique(axe=0

De même, la fonction suivante résume la moyenne, le nombre, l'écart type, le minimum et le maximum des variables numériques :

data.describe()

Étape 2 : Conduite de l'EDA

Maintenant que nous avons terminé le traitement des données, nous pouvons effectuer une analyse exploratoire des données. Voici les principales tâches que nous effectuerons à cette étape de notre projet de prédiction des maladies cardiaques :

Trouver des corrélations

Nous allons créer une matrice de corrélation qui nous aide à voir les corrélations entre différentes variables :

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

annot=Vrai,

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

Pour trouver des corrélations immédiates entre les caractéristiques, nous pouvons également créer des paires. Nous utiliserons de petits diagrammes de paires avec uniquement les variables continues pour approfondir les relations :

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

sns.pairplot(subData)

Utilisation du violon et des boîtes à moustaches

Avec Violin et Box plots, nous pouvons voir les statistiques de base et la distribution de nos données. Vous pouvez l'utiliser pour comparer la distribution d'une variable spécifique dans différentes catégories. Cela nous aidera également à identifier les valeurs aberrantes dans les données. Utilisez le code suivant :

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

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

plt.title ("Niveau de Thalach vs Maladie Cardiaque", fontsize=20)

plt.xlabel ("Cible de maladie cardiaque", taille de police = 16)

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

Dans le premier Violin and Box plot, nous constatons que les patients positifs ont une médiane inférieure pour la dépression ST que les patients négatifs. Nous allons donc utiliser un graphique pour comparer le niveau de dépression ST et les maladies cardiaques.

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

sns.boxplot(x= 'cible', y= 'thalach',hue=”sexe”, data=data )

plt.title ("Niveau de dépression ST vs maladie cardiaque", taille de police = 20)

plt.xlabel("Cible de maladie cardiaque",fontsize=16)

plt.ylabel("Dépression ST induite par l'exercice par rapport au repos", fontsize=16)

Ici, les patients positifs avaient une médiane plus élevée pour le niveau de dépression ST par rapport aux patients négatifs.

Filtrage des données

Nous allons maintenant filtrer les données en fonction des patients cardiaques positifs et négatifs. Nous commencerons par filtrer les données par patients cardiaques positifs :

pos_data = données[données['cible']==1]

pos_data.describe()

De même, nous filtrerons les données en fonction des patients cardiaques négatifs :

pos_data = données[données['cible']==0]

pos_data.describe()

Étape 3 : Utiliser des algorithmes d'apprentissage automatique

Préparation

Ici, nous allons préparer les données pour la formation en attribuant les caractéristiques à X et la dernière colonne au prédicteur Y :

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

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

Ensuite, nous diviserons les données en deux ensembles, ensemble d'apprentissage et ensemble de test :

depuis sklearn.model_selection importer train_test_split

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

Enfin, nous normaliserons les données afin que leur distribution ait une moyenne de 0 :

depuis sklearn.preprocessing importer StandardScaler

sc = Échelle Standard()

x_train = sc.fit_transform(x_train)

x_test = sc.transform(x_test)

Formation du modèle

Dans cette section, nous utiliserons plusieurs algorithmes d'apprentissage automatique et trouverons celui qui offre la plus grande précision :

1er modèle : régression logistique

de sklearn.metrics importer classification_report

de sklearn.linear_model importer LogisticRegression

model1 = LogisticRegression(random_state=1) # obtenir une instance du modèle

model1.fit(x_train, y_train) # Entraîner/Ajuster le modèle

y_pred1 = model1.predict(x_test) # obtenir y prédictions

print(classification_report(y_test, y_pred1)) # précision de sortie

La précision de ce modèle était de 74 %.

2e modèle : K-NN (K-Nearest Neighbours)

de sklearn.metrics importer classification_report

de sklearn.voisins importer KNeighboursClassifier

model2 = KNeighboursClassifier() # obtenir une instance du modèle

model2.fit(x_train, y_train) # Entraîner/Ajuster le modèle

y_pred2 = model2.predict(x_test) # obtenir y prédictions

print(classification_report(y_test, y_pred2)) # précision de sortie

La précision de ce modèle était de 75 %.

3ème modèle : Support Vector Machine (SVM)

de sklearn.metrics importer classification_report

depuis sklearn.svm importer SVC

model3 = SVC(random_state=1) # obtenir une instance du modèle

model3.fit(x_train, y_train) # Entraîner/Ajuster le modèle

y_pred3 = model3.predict(x_test) # obtenir y prédictions

print(classification_report(y_test, y_pred3)) # précision de sortie

La précision de ce modèle était de 75 %.

4e modèle : classificateur naïf de Bayes

de sklearn.metrics importer classification_report

de sklearn.naive_bayes importer GaussianNB

model4 = GaussianNB() # obtenir une instance du modèle

model4.fit(x_train, y_train) # Entraîner/Ajuster le modèle

y_pred4 = model4.predict(x_test) # obtenir y prédictions

print(classification_report(y_test, y_pred4)) # précision de sortie

La précision de ce modèle était de 77 %.

5e modèle : Forêt aléatoire

de sklearn.metrics importer classification_report

de sklearn.ensemble importer RandomForestClassifier

model6 = RandomForestClassifier(random_state=1)# obtenir l'instance du modèle

model6.fit(x_train, y_train) # Entraîner/Ajuster le modèle

y_pred6 = model6.predict(x_test) # obtenir y prédictions

print(classification_report(y_test, y_pred6)) # précision de sortie

Ce modèle avait la précision la plus élevée de 80 %.

6ème modèle : XGBoost

depuis xgboost importer XGBClassifier

model7 = XGBClassifier(random_state=1)

modèle7.fit(x_train, y_train)

y_pred7 = model7.predict(x_test)

print(classification_report(y_test, y_pred7))

La précision de ce modèle était de 69 %.

Après avoir testé différents algorithmes ML, nous avons constaté que le meilleur était Random Forest, car il nous offrait une précision optimale de 80 %.

Gardez à l'esprit que tout pourcentage de précision supérieur à 80 % est trop beau pour être vrai, et cela peut être dû à un surajustement. C'est pourquoi 80% est le nombre optimal à atteindre.

Étape 4 : Trouver le score de fonctionnalité

Ici, nous trouverons le score de fonctionnalité, qui nous aide à prendre des décisions importantes en nous indiquant quelle fonctionnalité a été la plus utile pour notre modèle :

# obtenir de l'importance

importance = model6.feature_importances_

# résumer l'importance des fonctionnalités

pour i,v dans énumérer(importance):

print('Fonction : %0d, Score : %.5f' % (i,v))

Nous avons constaté que les quatre principales caractéristiques étaient le type de douleur thoracique (cp), la fréquence cardiaque maximale atteinte (thalach), le nombre de vaisseaux principaux (ca) et la dépression du segment ST causée par l'exercice par rapport au repos (oldpeak).

Conclusion

Félicitations, vous avez maintenant terminé avec succès le projet de prédiction des maladies cardiaques. Nous avions 13 caractéristiques, parmi lesquelles nous avons constaté que les plus importantes étaient le type de douleur thoracique et la fréquence cardiaque maximale atteinte.

Nous avons testé six algorithmes ML différents et avons constaté que l'algorithme le plus précis était Random Forest. Vous devriez tester ce modèle avec l'ensemble de test et voir si ce modèle fonctionne bien.

D'autre part, si vous souhaitez en savoir plus sur l'apprentissage automatique et l'IA, nous vous recommandons de consulter nos cours sur l'IA . Vous étudierez directement auprès d'experts de l'industrie et travaillerez sur des projets industriels qui vous permettront de tester vos connaissances. Consultez-les si vous êtes intéressé par une carrière dans l'apprentissage automatique et l'IA.

Si vous souhaitez en savoir plus sur l'apprentissage automatique, consultez le programme Executive PG d'IIIT-B & upGrad en apprentissage automatique et IA, conçu pour les professionnels en activité et offrant plus de 450 heures de formation rigoureuse, plus de 30 études de cas et missions, IIIT -B Statut d'anciens élèves, 5+ projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.