Régression logistique en Python - Guide rapide
La régression logistique est une méthode statistique de classification des objets. Ce chapitre donnera une introduction à la régression logistique à l'aide de quelques exemples.
Classification
Pour comprendre la régression logistique, vous devez savoir ce que signifie la classification. Prenons les exemples suivants pour mieux comprendre -
- Un médecin classe la tumeur comme maligne ou bénigne.
- Une transaction bancaire peut être frauduleuse ou authentique.
Depuis de nombreuses années, les humains accomplissent de telles tâches - même si elles sont sujettes à des erreurs. La question est: pouvons-nous former des machines à effectuer ces tâches pour nous avec une meilleure précision?
Un tel exemple de machine effectuant la classification est l'e-mail Clientsur votre machine qui classe chaque courrier entrant comme «spam» ou «non spam» et il le fait avec une assez grande précision. La technique statistique de régression logistique a été appliquée avec succès dans le client de messagerie. Dans ce cas, nous avons formé notre machine à résoudre un problème de classification.
La régression logistique n'est qu'une partie de l'apprentissage automatique utilisée pour résoudre ce type de problème de classification binaire. Il existe plusieurs autres techniques d'apprentissage automatique qui sont déjà développées et qui sont utilisées pour résoudre d'autres types de problèmes.
Si vous avez remarqué, dans tous les exemples ci-dessus, le résultat de la prédication n'a que deux valeurs - Oui ou Non. Nous les appelons des classes - pour dire que nous disons que notre classificateur classe les objets en deux classes. En termes techniques, on peut dire que le résultat ou la variable cible est de nature dichotomique.
Il existe d'autres problèmes de classification dans lesquels la sortie peut être classée en plus de deux classes. Par exemple, étant donné un panier rempli de fruits, on vous demande de séparer les fruits de différentes sortes. Maintenant, le panier peut contenir des oranges, des pommes, des mangues, etc. Ainsi, lorsque vous séparez les fruits, vous les séparez en plus de deux classes. Il s'agit d'un problème de classification multivariée.
Considérez qu'une banque vous approche pour développer une application d'apprentissage automatique qui les aidera à identifier les clients potentiels qui ouvriraient un dépôt à terme (également appelé dépôt fixe par certaines banques) avec eux. La banque mène régulièrement une enquête au moyen d'appels téléphoniques ou de formulaires Web pour recueillir des informations sur les clients potentiels. L'enquête est de nature générale et est menée auprès d'un très large public, dont beaucoup pourraient ne pas être intéressés à traiter avec cette banque elle-même. Sur le reste, seuls quelques-uns pourraient être intéressés par l'ouverture d'un dépôt à terme. D'autres peuvent être intéressés par d'autres facilités offertes par la banque. L'enquête n'est donc pas nécessairement menée pour identifier les clients qui ouvrent des TD. Votre tâche consiste à identifier tous les clients à forte probabilité d'ouvrir TD à partir des énormes données d'enquête que la banque va partager avec vous.
Heureusement, un tel type de données est accessible au public pour ceux qui aspirent à développer des modèles d'apprentissage automatique. Ces données ont été préparées par certains étudiants de l'UC Irvine avec un financement externe. La base de données est disponible dans le cadre deUCI Machine Learning Repositoryet est largement utilisé par les étudiants, les éducateurs et les chercheurs du monde entier. Les données peuvent être téléchargées à partir d' ici .
Dans les chapitres suivants, effectuons maintenant le développement de l'application en utilisant les mêmes données.
Dans ce chapitre, nous comprendrons en détail le processus de mise en place d'un projet pour effectuer une régression logistique en Python.
Installer Jupyter
Nous utiliserons Jupyter - l'une des plates-formes les plus utilisées pour l'apprentissage automatique. Si vous n'avez pas installé Jupyter sur votre machine, téléchargez-le ici . Pour l'installation, vous pouvez suivre les instructions sur leur site pour installer la plateforme. Comme le site le suggère, vous préférerez peut-être utiliserAnaconda Distributionqui vient avec Python et de nombreux packages Python couramment utilisés pour le calcul scientifique et la science des données. Cela réduira le besoin d'installer ces packages individuellement.
Après l'installation réussie de Jupyter, démarrez un nouveau projet, votre écran à ce stade ressemblerait à ce qui suit prêt à accepter votre code.
Maintenant, changez le nom du projet de Untitled1 to “Logistic Regression” en cliquant sur le nom du titre et en le modifiant.
Tout d'abord, nous importerons plusieurs packages Python dont nous aurons besoin dans notre code.
Importation de packages Python
Pour cela, tapez ou copiez-collez le code suivant dans l'éditeur de code -
In [1]: # import statements
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_splitVotre Notebook devrait ressembler à ce qui suit à ce stade -
Exécutez le code en cliquant sur le Runbouton. Si aucune erreur n'est générée, vous avez correctement installé Jupyter et êtes maintenant prêt pour le reste du développement.
Les trois premières instructions import importent les packages pandas, numpy et matplotlib.pyplot dans notre projet. Les trois instructions suivantes importent les modules spécifiés depuis sklearn.
Notre prochaine tâche est de télécharger les données nécessaires à notre projet. Nous l'apprendrons dans le prochain chapitre.
Les étapes à suivre pour obtenir des données pour effectuer une régression logistique en Python sont décrites en détail dans ce chapitre.
Téléchargement de l'ensemble de données
Si vous n'avez pas encore téléchargé le jeu de données UCI mentionné précédemment, téléchargez-le maintenant à partir d' ici . Cliquez sur le dossier de données. Vous verrez l'écran suivant -
Téléchargez le fichier bank.zip en cliquant sur le lien indiqué. Le fichier zip contient les fichiers suivants -
Nous utiliserons le fichier bank.csv pour le développement de notre modèle. Le fichier bank-names.txt contient la description de la base de données dont vous aurez besoin ultérieurement. Le fichier bank-full.csv contient un ensemble de données beaucoup plus volumineux que vous pouvez utiliser pour des développements plus avancés.
Ici, nous avons inclus le fichier bank.csv dans le zip source téléchargeable. Ce fichier contient les champs délimités par des virgules. Nous avons également apporté quelques modifications au fichier. Il est recommandé d'utiliser le fichier inclus dans le zip source du projet pour votre apprentissage.
Chargement des données
Pour charger les données du fichier csv que vous venez de copier, tapez l'instruction suivante et exécutez le code.
In [2]: df = pd.read_csv('bank.csv', header=0)Vous pourrez également examiner les données chargées en exécutant l'instruction de code suivante -
IN [3]: df.head()Une fois la commande exécutée, vous verrez la sortie suivante -
Fondamentalement, il a imprimé les cinq premières lignes des données chargées. Examinez les 21 colonnes présentes. Nous n'utiliserons que quelques colonnes de celles-ci pour le développement de notre modèle.
Ensuite, nous devons nettoyer les données. Les données peuvent contenir des lignes avecNaN. Pour éliminer ces lignes, utilisez la commande suivante -
IN [4]: df = df.dropna()Heureusement, le fichier bank.csv ne contient aucune ligne avec NaN, donc cette étape n'est pas vraiment nécessaire dans notre cas. Cependant, en général, il est difficile de découvrir de telles lignes dans une énorme base de données. Il est donc toujours plus sûr d'exécuter l'instruction ci-dessus pour nettoyer les données.
Note - Vous pouvez facilement examiner la taille des données à tout moment en utilisant l'instruction suivante -
IN [5]: print (df.shape)
(41188, 21)Le nombre de lignes et de colonnes serait imprimé dans la sortie comme indiqué dans la deuxième ligne ci-dessus.
La prochaine chose à faire est d'examiner l'adéquation de chaque colonne pour le modèle que nous essayons de construire.
Chaque fois qu'une organisation mène une enquête, elle essaie de collecter autant d'informations que possible auprès du client, avec l'idée que ces informations seraient utiles à l'organisation d'une manière ou d'une autre, à un moment ultérieur. Pour résoudre le problème actuel, nous devons récupérer les informations directement pertinentes à notre problème.
Affichage de tous les champs
Voyons maintenant comment sélectionner les champs de données qui nous sont utiles. Exécutez l'instruction suivante dans l'éditeur de code.
In [6]: print(list(df.columns))Vous verrez la sortie suivante -
['age', 'job', 'marital', 'education', 'default', 'housing', 'loan',
'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays',
'previous', 'poutcome', 'emp_var_rate', 'cons_price_idx', 'cons_conf_idx',
'euribor3m', 'nr_employed', 'y']La sortie affiche les noms de toutes les colonnes de la base de données. La dernière colonne «y» est une valeur booléenne indiquant si ce client a un dépôt à terme auprès de la banque. Les valeurs de ce champ sont «y» ou «n». Vous pouvez lire la description et le but de chaque colonne dans le fichier banks-name.txt qui a été téléchargé dans le cadre des données.
Élimination des champs indésirables
En examinant les noms des colonnes, vous saurez que certains des champs n'ont aucune signification pour le problème en question. Par exemple, des champs tels quemonth, day_of_week, campagne, etc. ne nous sont d'aucune utilité. Nous éliminerons ces champs de notre base de données. Pour supprimer une colonne, nous utilisons la commande drop comme indiqué ci-dessous -
In [8]: #drop columns which are not needed.
df.drop(df.columns[[0, 3, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19]],
axis = 1, inplace = True)La commande indique que supprimer la colonne numéro 0, 3, 7, 8, etc. Pour vous assurer que l'index est correctement sélectionné, utilisez l'instruction suivante -
In [7]: df.columns[9]
Out[7]: 'day_of_week'Cela imprime le nom de la colonne pour l'index donné.
Après avoir supprimé les colonnes qui ne sont pas requises, examinez les données avec l'instruction head. La sortie d'écran est affichée ici -
In [9]: df.head()
Out[9]:
job marital default housing loan poutcome y
0 blue-collar married unknown yes no nonexistent 0
1 technician married no no no nonexistent 0
2 management single no yes no success 1
3 services married no no no nonexistent 0
4 retired married no yes no success 1Désormais, nous n'avons que les champs qui nous semblent importants pour notre analyse et nos prévisions de données. L'importance deData Scientistentre en image à cette étape. Le data scientist doit sélectionner les colonnes appropriées pour la construction du modèle.
Par exemple, le type de jobbien qu'à première vue, cela ne convainc pas tout le monde de l'inclure dans la base de données, ce sera un champ très utile. Tous les types de clients n'ouvriront pas le TD. Les personnes à faible revenu peuvent ne pas ouvrir les DT, tandis que les personnes à revenu élevé placent généralement leur argent excédentaire dans des DT. Le type d'emploi devient donc significativement pertinent dans ce scénario. De même, sélectionnez soigneusement les colonnes qui vous semblent pertinentes pour votre analyse.
Dans le chapitre suivant, nous préparerons nos données pour construire le modèle.
Pour créer le classificateur, nous devons préparer les données dans un format demandé par le module de construction du classificateur. Nous préparons les données en faisantOne Hot Encoding.
Codage des données
Nous discuterons brièvement de ce que nous entendons par encodage des données. Tout d'abord, exécutons le code. Exécutez la commande suivante dans la fenêtre de code.
In [10]: # creating one hot encoding of the categorical columns.
data = pd.get_dummies(df, columns =['job', 'marital', 'default', 'housing', 'loan', 'poutcome'])Comme le dit le commentaire, l'instruction ci-dessus créera le seul encodage à chaud des données. Voyons ce que cela a créé? Examinez les données créées appelées“data” en imprimant les enregistrements de tête dans la base de données.
In [11]: data.head()Vous verrez la sortie suivante -
Pour comprendre les données ci-dessus, nous allons lister les noms de colonnes en exécutant le data.columns commande comme indiqué ci-dessous -
In [12]: data.columns
Out[12]: Index(['y', 'job_admin.', 'job_blue-collar', 'job_entrepreneur',
'job_housemaid', 'job_management', 'job_retired', 'job_self-employed',
'job_services', 'job_student', 'job_technician', 'job_unemployed',
'job_unknown', 'marital_divorced', 'marital_married', 'marital_single',
'marital_unknown', 'default_no', 'default_unknown', 'default_yes',
'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
'loan_unknown', 'loan_yes', 'poutcome_failure', 'poutcome_nonexistent',
'poutcome_success'], dtype='object')Maintenant, nous allons expliquer comment le seul encodage à chaud est effectué par le get_dummiescommander. La première colonne de la base de données nouvellement générée est le champ «y» qui indique si ce client s'est abonné à un TD ou non. Maintenant, regardons les colonnes qui sont encodées. La première colonne encodée est“job”. Dans la base de données, vous constaterez que la colonne «emploi» a de nombreuses valeurs possibles telles que «admin», «cols bleus», «entrepreneur», etc. Pour chaque valeur possible, nous avons une nouvelle colonne créée dans la base de données, avec le nom de la colonne ajouté comme préfixe.
Ainsi, nous avons des colonnes appelées «job_admin», «job_blue-necklace», etc. Pour chaque champ encodé dans notre base de données d'origine, vous trouverez une liste de colonnes ajoutées dans la base de données créée avec toutes les valeurs possibles que la colonne prend dans la base de données d'origine. Examinez attentivement la liste des colonnes pour comprendre comment les données sont mappées à une nouvelle base de données.
Comprendre le mappage de données
Pour comprendre les données générées, imprimons toutes les données à l'aide de la commande data. La sortie partielle après l'exécution de la commande est indiquée ci-dessous.
In [13]: data
L'écran ci-dessus montre les douze premières lignes. Si vous faites défiler vers le bas, vous verrez que le mappage est effectué pour toutes les lignes.
Une sortie d'écran partielle plus bas dans la base de données est affichée ici pour votre référence rapide.
Pour comprendre les données mappées, examinons la première ligne.
Il indique que ce client ne s'est pas abonné à TD comme indiqué par la valeur dans le champ «y». Il indique également que ce client est un client «cols bleus». En défilant horizontalement, cela vous indiquera qu'il a un «logement» et n'a pris aucun «prêt».
Après cet encodage à chaud, nous avons besoin d'un traitement supplémentaire des données avant de pouvoir commencer à construire notre modèle.
Laisser tomber «l'inconnu»
Si nous examinons les colonnes de la base de données mappée, vous trouverez la présence de quelques colonnes se terminant par «inconnu». Par exemple, examinez la colonne à l'index 12 avec la commande suivante affichée dans la capture d'écran -
In [14]: data.columns[12]
Out[14]: 'job_unknown'Cela indique que le travail du client spécifié est inconnu. De toute évidence, il ne sert à rien d'inclure de telles colonnes dans notre analyse et la construction de modèles. Ainsi, toutes les colonnes avec la valeur «inconnue» doivent être supprimées. Ceci est fait avec la commande suivante -
In [15]: data.drop(data.columns[[12, 16, 18, 21, 24]], axis=1, inplace=True)Assurez-vous de spécifier les bons numéros de colonne. En cas de doute, vous pouvez examiner le nom de la colonne à tout moment en spécifiant son index dans la commande colonnes comme décrit précédemment.
Après avoir supprimé les colonnes indésirables, vous pouvez examiner la liste finale des colonnes comme indiqué dans la sortie ci-dessous -
In [16]: data.columns
Out[16]: Index(['y', 'job_admin.', 'job_blue-collar', 'job_entrepreneur',
'job_housemaid', 'job_management', 'job_retired', 'job_self-employed',
'job_services', 'job_student', 'job_technician', 'job_unemployed',
'marital_divorced', 'marital_married', 'marital_single', 'default_no',
'default_yes', 'housing_no', 'housing_yes', 'loan_no', 'loan_yes',
'poutcome_failure', 'poutcome_nonexistent', 'poutcome_success'],
dtype='object')À ce stade, nos données sont prêtes pour la création de modèles.
Nous avons environ quarante et un mille disques. Si nous utilisons toutes les données pour la création de modèles, nous ne disposerons d'aucune donnée à tester. Donc, généralement, nous divisons l'ensemble de données en deux parties, disons un pourcentage de 70/30. Nous utilisons 70% des données pour la construction de modèles et le reste pour tester la précision de la prédiction de notre modèle créé. Vous pouvez utiliser un ratio de fractionnement différent selon vos besoins.
Création d'un tableau d'entités
Avant de diviser les données, nous séparons les données en deux tableaux X et Y. Le tableau X contient toutes les fonctionnalités (colonnes de données) que nous voulons analyser et le tableau Y est un tableau unidimensionnel de valeurs booléennes qui est la sortie de la prédiction. Pour comprendre cela, exécutons du code.
Tout d'abord, exécutez l'instruction Python suivante pour créer le tableau X -
In [17]: X = data.iloc[:,1:]Pour examiner le contenu de X utilisation headpour imprimer quelques enregistrements initiaux. L'écran suivant montre le contenu du tableau X.
In [18]: X.head ()
Le tableau comporte plusieurs lignes et 23 colonnes.
Ensuite, nous allons créer un tableau de sortie contenant "y" valeurs.
Création d'un tableau de sortie
Pour créer un tableau pour la colonne de valeur prédite, utilisez l'instruction Python suivante -
In [19]: Y = data.iloc[:,0]Examinez son contenu en appelant head. La sortie d'écran ci-dessous montre le résultat -
In [20]: Y.head()
Out[20]: 0 0
1 0
2 1
3 0
4 1
Name: y, dtype: int64Maintenant, divisez les données à l'aide de la commande suivante -
In [21]: X_train, X_test, Y_train, Y_test = train_test_split(X, Y, random_state=0)Cela créera les quatre tableaux appelés X_train, Y_train, X_test, and Y_test. Comme précédemment, vous pouvez examiner le contenu de ces tableaux en utilisant la commande head. Nous utiliserons les tableaux X_train et Y_train pour entraîner notre modèle et les tableaux X_test et Y_test pour tester et valider.
Maintenant, nous sommes prêts à construire notre classificateur. Nous l'examinerons dans le prochain chapitre.
Il n'est pas nécessaire que vous ayez à créer le classificateur à partir de zéro. La construction de classificateurs est complexe et nécessite la connaissance de plusieurs domaines tels que les statistiques, les théories des probabilités, les techniques d'optimisation, etc. Il existe plusieurs bibliothèques pré-construites disponibles sur le marché qui ont une implémentation entièrement testée et très efficace de ces classificateurs. Nous utiliserons un tel modèle pré-construit de lasklearn.
Le classificateur sklearn
La création du classificateur de régression logistique à partir de la boîte à outils sklearn est simple et se fait dans une seule instruction de programme, comme indiqué ici -
In [22]: classifier = LogisticRegression(solver='lbfgs',random_state=0)Une fois le classificateur créé, vous alimenterez vos données d'entraînement dans le classificateur afin qu'il puisse régler ses paramètres internes et être prêt pour les prédictions sur vos données futures. Pour régler le classificateur, nous exécutons l'instruction suivante -
In [23]: classifier.fit(X_train, Y_train)Le classificateur est maintenant prêt pour les tests. Le code suivant est la sortie de l'exécution des deux instructions ci-dessus -
Out[23]: LogisticRegression(C = 1.0, class_weight = None, dual = False,
fit_intercept=True, intercept_scaling=1, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2', random_state=0,
solver='lbfgs', tol=0.0001, verbose=0, warm_start=False))Maintenant, nous sommes prêts à tester le classificateur créé. Nous en traiterons dans le prochain chapitre.
Nous devons tester le classificateur créé ci-dessus avant de le mettre en production. Si les tests révèlent que le modèle ne répond pas à la précision souhaitée, nous devrons reprendre le processus ci-dessus, sélectionner un autre ensemble de fonctionnalités (champs de données), reconstruire le modèle et le tester. Ce sera une étape itérative jusqu'à ce que le classificateur réponde à votre exigence de précision souhaitée. Alors testons notre classificateur.
Prédire les données de test
Pour tester le classifieur, nous utilisons les données de test générées à l'étape précédente. Nous appelons lepredict méthode sur l'objet créé et passez la X tableau des données de test comme indiqué dans la commande suivante -
In [24]: predicted_y = classifier.predict(X_test)Cela génère un tableau unidimensionnel pour l'ensemble de données d'apprentissage complet donnant la prédiction pour chaque ligne du tableau X. Vous pouvez examiner ce tableau en utilisant la commande suivante -
In [25]: predicted_yCe qui suit est la sortie lors de l'exécution des deux commandes ci-dessus -
Out[25]: array([0, 0, 0, ..., 0, 0, 0])Le résultat indique que les trois premier et dernier clients ne sont pas les candidats potentiels pour le Term Deposit. Vous pouvez examiner l'ensemble du tableau pour trier les clients potentiels. Pour ce faire, utilisez l'extrait de code Python suivant -
In [26]: for x in range(len(predicted_y)):
if (predicted_y[x] == 1):
print(x, end="\t")La sortie de l'exécution du code ci-dessus est indiquée ci-dessous -
La sortie montre les index de toutes les lignes qui sont des candidats probables pour l'abonnement à TD. Vous pouvez maintenant donner cette sortie à l'équipe marketing de la banque qui récupère les coordonnées de chaque client de la ligne sélectionnée et poursuit son travail.
Avant de mettre ce modèle en production, nous devons vérifier l'exactitude de la prédiction.
Vérification de l'exactitude
Pour tester la précision du modèle, utilisez la méthode de score sur le classificateur comme indiqué ci-dessous -
In [27]: print('Accuracy: {:.2f}'.format(classifier.score(X_test, Y_test)))La sortie d'écran de l'exécution de cette commande est indiquée ci-dessous -
Accuracy: 0.90Cela montre que la précision de notre modèle est de 90%, ce qui est considéré comme très bon dans la plupart des applications. Ainsi, aucun réglage supplémentaire n'est requis. Maintenant, notre client est prêt à lancer la prochaine campagne, à obtenir la liste des clients potentiels et à les chasser pour ouvrir le TD avec un taux de réussite probablement élevé.
Comme vous l'avez vu dans l'exemple ci-dessus, l'application de la régression logistique pour l'apprentissage automatique n'est pas une tâche difficile. Cependant, il a ses propres limites. La régression logistique ne pourra pas gérer un grand nombre de caractéristiques catégorielles. Dans l'exemple dont nous avons discuté jusqu'à présent, nous avons réduit le nombre de fonctionnalités dans une très large mesure.
Cependant, si ces caractéristiques étaient importantes dans notre prédiction, nous aurions été obligés de les inclure, mais alors la régression logistique ne nous donnerait pas une bonne précision. La régression logistique est également vulnérable au surajustement. Il ne peut pas être appliqué à un problème non linéaire. Il fonctionnera mal avec des variables indépendantes qui ne sont pas corrélées à la cible et sont corrélées les unes aux autres. Ainsi, vous devrez évaluer soigneusement l'adéquation de la régression logistique au problème que vous essayez de résoudre.
Il existe de nombreux domaines de l'apprentissage automatique dans lesquels d'autres techniques sont spécifiées. Pour n'en nommer que quelques-uns, nous avons des algorithmes tels que les k-plus proches voisins (kNN), la régression linéaire, les machines vectorielles de support (SVM), les arbres de décision, les bayes naïves, etc. Avant de finaliser sur un modèle particulier, vous devrez évaluer l'applicabilité de ces différentes techniques au problème que nous essayons de résoudre.
La régression logistique est une technique statistique de classification binaire. Dans ce didacticiel, vous avez appris à entraîner la machine à utiliser la régression logistique. En créant des modèles d'apprentissage automatique, l'exigence la plus importante est la disponibilité des données. Sans données adéquates et pertinentes, vous ne pouvez pas simplement faire apprendre la machine.
Une fois que vous avez des données, votre prochaine tâche principale consiste à nettoyer les données, à éliminer les lignes et les champs indésirables et à sélectionner les champs appropriés pour le développement de votre modèle. Après cela, vous devez mapper les données dans un format requis par le classificateur pour son apprentissage. Ainsi, la préparation des données est une tâche majeure dans toute application d'apprentissage automatique. Une fois que vous êtes prêt avec les données, vous pouvez sélectionner un type particulier de classificateur.
Dans ce didacticiel, vous avez appris à utiliser un classificateur de régression logistique fourni dans le sklearnbibliothèque. Pour former le classificateur, nous utilisons environ 70% des données pour entraîner le modèle. Nous utilisons le reste des données pour les tests. Nous testons la précision du modèle. Si ce n'est pas dans les limites acceptables, nous revenons à la sélection du nouvel ensemble de fonctionnalités.
Encore une fois, suivez tout le processus de préparation des données, entraînez le modèle et testez-le jusqu'à ce que vous soyez satisfait de sa précision. Avant de vous lancer dans un projet d'apprentissage automatique, vous devez apprendre et vous familiariser avec une grande variété de techniques qui ont été développées jusqu'à présent et qui ont été appliquées avec succès dans l'industrie.