Cet article a été publié dans le cadre de la Blogathon sur la science des données

Salut les amis, dans cet article, nous allons comprendre comment analyser et prédire si une personne qui est montée à bord du RMS Titanic a une chance de survie ou non, en utilisant le modèle de régression logistique de Machine Learning.

Brève description de la régression logistique :

Une description simple mais précise de la description logistique serait : « c’est un algorithme de classification d’apprentissage supervisé utilisé pour prédire la probabilité d’une variable cible. La nature de la cible ou de la variable dépendante est dichotomique, ce qui signifie qu’il n’y aurait que deux classes possibles. comme indiqué dans les points du tutoriel article.

Le graphique de la régression logistique est le suivant :

régression logistique

source de l’image : relier

Plongeons dans le processus .. !! :

Commençons maintenant la partie principale de cet article.

Si vous préférez une compréhension audio-visuelle de ce processus, vous pouvez vous référer à ce vidéo au dessous de. Il passe en revue tout dans cet article avec un peu plus de détails et vous aidera à commencer facilement à programmer votre propre modèle d’apprentissage automatique, même si vous n’en avez pas. python installé sur votre ordinateur.

Ou vous pouvez utiliser les deux comme matériel supplémentaire pour en savoir plus sur l’apprentissage automatique !

Pour une meilleure compréhension, divisons la tâche en parties plus petites et décrivons-les dans un flux de travail comme indiqué ci-dessous :

(la source de l’image est la vidéo liée ci-dessus : lien_image )

cycle de vie de la science des données

Comme nous savons maintenant ce que nous devons faire, pour accomplir cette tâche, nous commencerons par la toute première et la plus importante chose nécessaire en apprentissage automatique, un Base de données.

Qu’est-ce qu’un jeu de données :

UNE base de données, comme son nom l’indique, est une collection de données. Dans les projets de Machine Learning, nous avons besoin d’une formation base de données. C’est le réel base de données utilisé pour entraîner le modèle à effectuer diverses actions.

Ici, dans ce cas, nous utiliserons un jeu de données disponible sur Internet. On peut trouver divers ensembles de données de ce type sur Internet.

L’ensemble de données que j’ai utilisé dans mon code était les données disponibles sur Kaggle. Vous pouvez également le télécharger sur ici.

Une chose doit être gardée à l’esprit, plus les données sont volumineuses, plus nous pouvons entraîner notre modèle et plus nos résultats sont précis. Ne vous inquiétez pas si tout cela vous semble bizarre, tout aura un sens dans quelques minutes. ??

Commençons par notre codage :

Pour coder, car nous savons que nous avons besoin d’un environnement approprié, ici, dans mon cas, j’ai utilisé Google Colab, car cela réduit la tâche trépidante de compilation et d’exécution du programme sur votre PC. Vous pouvez utiliser n’importe quel éditeur comme vous le souhaitez.

La première chose à faire est d’importer les dépendances que nous utiliserons dans notre code.

Importation des dépendances :

Nous utiliserons : NumPy, pandas,matplotlib, seaborn,apprendre.

import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

Au fur et à mesure que nous avancerons, vous apprendrez à connaître l’utilisation de chacun de ces modules.

Maintenant, nous devons télécharger l’ensemble de données téléchargé, dans ce programme, afin que notre code puisse lire les données et effectuer les actions nécessaires en l’utilisant.

Comme nous avons téléchargé un fichier CSV, nous utiliserons Pandas pour stocker ces données dans une variable.

titanic_data = pd.read_csv('/content/train.csv')

Notre jeu de données est maintenant stocké dans la variable nommée titanic_data.

Pour avoir une brève idée de la façon dont les données sont chargées, nous utilisons la commande “variable_name.head()” pour avoir un aperçu de l’ensemble de données sous la forme d’un tableau.

titanic_data.head()

Le résultat est le suivant :

chef de données | Prédiction de survie du Titanic

La signification des valeurs (SibSp, Parch) peut être trouvée sur le site Web à partir duquel nous avons téléchargé le jeu de données.

Nous avons appris de Kaggle lors du téléchargement de l’ensemble de données, que les données ont 891 lignes et 12 colonnes.

Maintenant, vérifions combien de cellules sont laissées vides dans le tableau.

titanic_data.isnull().sum()

Le résultat est le suivant :

valeurs manquantes | Prédiction de survie du Titanic

Nous ne pouvons pas laisser les cellules vides, nous devons donc remplir les tableaux avec les valeurs les plus appropriées.

Gestion des valeurs manquantes :

Supprimer la colonne “Cabine” du bloc de données car cela n’aura pas beaucoup d’importance

titanic_data = titanic_data.drop(columns='Cabin', axis=1)

Remplacer les valeurs manquantes dans la colonne « Âge » par la valeur moyenne

titanic_data['Age'].fillna(titanic_data['Age'].mean(), inplace=True)

Trouver la valeur de mode de la colonne “Embarqué” car elle s’est produite le nombre maximum de fois

print(titanic_data['Embarked'].mode())

Remplacement des valeurs manquantes dans la colonne “Embarqué” par la valeur de mode

titanic_data['Embarked'].fillna(titanic_data['Embarked'].mode()[0], inplace=True)

Vérifions maintenant s’il reste encore des cellules vides.

En exécutant à nouveau la commande isnull(), nous obtenons une sortie satisfaisante, qu’aucune cellule vide de ce type n’est présente.

Nous avons déjà remarqué dans le tableau qu’il y a deux colonnes qui contiennent des valeurs de type chaîne : la colonne “Sexe” et la colonne “Berth”.

Transformation en une colonne catégorique.

Convertissons-le en valeurs de type entier et transformons-le en une colonne catégorielle :

titanic_data.replace({'Sex':{'male':0,'female':1}, 'Embarked':{'S':0,'C':1,'Q':2}}, inplace=True)

Maintenant, si nous exécutons à nouveau la commande titanic_data.head(), nous constatons que les valeurs ont été remplacées avec succès.

On voit aussi qu’il y a peu de colonnes, qui n’ont pas beaucoup d’importance dans ce processus. Débarrassons-nous d’eux.

 titanic_data= titanic_data.drop(columns = ['PassengerId','Name','Ticket','Survived'],axis=1)

Il est maintenant temps de commencer à mettre en œuvre l’apprentissage automatique.

Séparons les données en variables cible et caractéristique.

X = titanic_data.drop(columns = ['PassengerId','Name','Ticket','Survived'],axis=1)
Y = titanic_data['Survived']

Ici, X est la variable de fonctionnalité, contenant toutes les fonctionnalités telles que Pclass, Age, Sex, Embarked, etc. à l’exception de la colonne Survived.

Y, d’autre part, est la variable cible, car c’est le résultat que nous voulons déterminer, c’est-à-dire si une personne est en vie.

Maintenant, nous allons diviser les données en quatre variables, à savoir X_train, Y_train, X_test, Y_test.

X_train, X_test, Y_train, Y_test = train_test_split(X,Y, test_size=0.2, random_state=2)

Comprenons les variables :

X_train : contient un ensemble de valeurs de la variable ‘X’

Y_train : contient la sortie (si la personne est vivante ou morte) de la valeur correspondante de X_train.

X_test : contient un ensemble de valeurs de la variable ‘X’, à l’exclusion de celles de X_train.

Y_train : contient la sortie (que la personne soit vivante ou morte) de la valeur correspondante de X_test.

test_size : représente le rapport en pourcentage de X_train:X_test (ici 0,2 signifie que les données seront séparées dans les variables X_train et X_test dans un rapport 80:20). Vous pouvez utiliser n’importe quelle valeur que vous voulez. Une valeur <0,3 est préférée

Régression logistique :

Créons un modèle nommé modèle

model = LogisticRegression()

Entraînons maintenant le modèle, avec nos valeurs d’entraînement (X_train , Y_train)

model.fit(X_train, Y_train)

Le modèle s’entraîne de la manière suivante : ” Lorsque les valeurs de X sont celles-ci, la valeur de Y est celle-ci.”

Vérification de la précision :

Vérification de la précision du moment où notre modèle essaie de prédire les valeurs, à l’aide de nos données d’entraînement :

Nommons une variable X_train_prediction, qui stockera toutes les sorties prédictives des valeurs X_train.

X_train_prediction = model.predict(X_train)

Maintenant, pour vérifier la précision de sa prédiction, nous comparons les valeurs de X_train_prediction avec Y_train, qui étaient les données réelles d’origine.

training_data_accuracy = accuracy_score(Y_train, X_train_prediction)
print('Accuracy score of training data : ', training_data_accuracy)

La sortie est de 0,8075842696629213, ce qui est plutôt correct.

Maintenant, essayons à nouveau avec X_test et Y_test :

X_test_prediction = model.predict(X_test)
test_data_accuracy = accuracy_score(Y_test, X_test_prediction)
print('Accuracy score of test data : ', test_data_accuracy)

La sortie est de 0,7821229050279329, ce qui est très proche de notre prédiction de données de test.

Ainsi, notre modèle est assez précis selon les données que nous avons reçues.

Recherche d’une personne aléatoire :

Vérifions maintenant une personne aléatoire en utilisant des données aléatoires de la table non éditée de Kaggle.

input_data = (3,0,35,0,0,8.05,0)  # Note that these datas exclude the Survived data, as it is to be determined from the model itself

Modifions maintenant ces valeurs en un tableau NumPy :

input_data_as_numpy_array = np.asarray(input_data)

Comme notre modèle a été formé dans différentes dimensions, nous devons le remodeler en fonction de nos dimensions cibles.

input_data_reshaped = input_data_as_numpy_array.reshape(1,-1)

Maintenant, prédisons à l’aide de notre modèle :

prediction = model.predict(input_data_reshaped)
#print(prediction)
if prediction[0]==0:
    print("Dead")
if prediction[0]==1:
    print("Alive")

Lors de l’exécution du code, nous obtenons exactement le même résultat, que celui donné, dans le tableau.

Nous pouvons donc conclure que notre modèle fonctionne bien. Vous pouvez entraîner le modèle à l’aide d’un ensemble de données plus volumineux pour obtenir de meilleurs résultats.

Notes de fin :

Le résultat de tout modèle d’apprentissage automatique peut être rendu plus précis à l’aide d’un ensemble de données plus volumineux, mais ce sera beaucoup plus fastidieux et chronophage. N’hésitez pas à ajouter tout type de modifications nécessaires à ce code et à le personnaliser selon vos besoins. Une logique similaire peut être appliquée pour effectuer divers types de prédictions.

Merci d’avoir lu… Bonne journée..!!

A propos de l’auteur:

Salut, je suis Pinak Datta, actuellement, étudiant en deuxième année, poursuivant des études d’ingénieur en informatique à l’Institut de technologie industrielle de Kalinga. J’aime le développement Web, le codage compétitif et un peu d’apprentissage automatique. N’hésitez pas à me contacter via mes réseaux sociaux.

Connecté

Instagram

Facebook

Courrier

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.




Source de l’article