Python

Python pour la data science et le

machine learning
Copyright 2021 - Tous droits réservés.
Le contenu de ce livre ne peut être reproduit, dupliqué ou transmis sans l'autorisation écrite
de l'auteur.

En aucun cas, l'éditeur ne pourra être tenu pour responsable de toute réparation, dommage
ou perte monétaire résultant directement ou indirectement des informations contenues
dans le présent document.
Avis juridique :

Vous ne pouvez pas modifier, distribuer, vendre, utiliser, citer ou paraphraser une partie du
contenu de ce livre sans l'accord de l'auteur.

Avis de non-responsabilité :
Veuillez noter que les informations contenues dans ce document sont uniquement destinées
à des fins éducatives et de divertissement. Aucune garantie de quelque nature que ce soit
n'est exprimée ou sous-entendue. Les lecteurs reconnaissent que l'auteur ne donne pas de
conseils juridiques, financiers, médicaux ou professionnels. Veuillez consulter un
professionnel agréé avant d'essayer les techniques décrites dans ce livre.

En lisant ce document, le lecteur accepte qu'en aucun cas l'auteur ne soit responsable des
pertes, directes ou indirectes, résultant de l'utilisation des informations contenues dans ce
document, y compris, mais sans s'y limiter, les erreurs, les omissions ou les inexactitudes.
Table des matières
Première partie - Introduction à la data science et à le machine learning
Qu'est-ce que la data science ?
Quelle est l'importance de la data science ?
Limites de la data science
Qu'est-ce que le machine learning ?
Quelle est l'importance de le machine learning ?
Limites de le machine learning
Data science et apprentissage automatique

Deuxième partie - Présentation de NumPy

Qu'est-ce que la bibliothèque NumPy ?
Comment créer un tableau NumPy
Mise en forme et remise en forme d'un tableau NumPy
Indexer et découper un tableau NumPy
Empiler et concaténer des tableaux NumPy
Diffusion dans les tableaux NumPy
NumPy Ufuncs
Faire des maths avec les tableaux NumPy
Tableaux NumPy et images

Troisième partie - Manipulation de données avec Pandas

Première question : Comment créer un DataFrame Pandas ?
Question 2 - Comment sélectionner une colonne ou un index dans un
DataFrame ?
Question 3 : Comment ajouter une ligne, une colonne ou un index à un
DataFrame ?
Question 4 : Comment supprimer des indices, des lignes ou des colonnes d'un
cadre de données ?
Question cinq : Comment renommer les colonnes ou l'index d'un DataFrame ?
Question six : Comment formater les données du DataFrame ?
Question sept : Comment créer un DataFrame vide ?
Question huit : Lorsque j'importerai des données, Pandas reconnaîtra-t-il les
dates ?
Question neuf : Quand un DataFrame doit-il être remodelé ? Pourquoi et
comment ?
 Question dix : Comment faire pour itérer sur un DataFrame ?
Question 11 : Comment écrire un DataFrame dans un fichier ?

Quatrième partie - Visualisation de données avec Matplotlib et Seaborn

Utilisation de Matplotlib pour générer des histogrammes
Utilisation de Matplotlib pour générer des diagrammes de dispersion
Utilisation de Matplotlib pour générer des diagrammes à barres
Utilisation de Matplotlib pour générer des diagrammes à secteurs
Visualiser les données avec Seaborn
Utilisation de Seaborn pour générer des histogrammes
Utilisation de Seaborn pour générer des diagrammes de dispersion
Utiliser Seaborn pour générer des cartes thermiques
Utilisation de Seaborn pour générer un diagramme de paires

Cinquième partie - Un guide approfondi de le machine learning

Le machine learning d'hier à aujourd'hui
Fonctionnalités de le machine learning
Les différents types d'apprentissage automatique
Algorithmes courants d'apprentissage automatique
Classificateur gaussien Naive Bayes
Voisins les plus proches (K-Nearest Neighbors)
Algorithme d'apprentissage de la machine à vecteur de support
Ajustement des machines à vecteurs de support
Algorithme d'apprentissage automatique de régression linéaire
Algorithme d'apprentissage automatique de régression logistique
Un modèle de régression logistique
Algorithme d'apprentissage automatique de l'arbre de décision
Algorithme d'apprentissage automatique Random Forest
Réseaux neuronaux artificiels Algorithme d'apprentissage automatique
Étapes de le machine learning
Évaluation d'un modèle d'apprentissage automatique
Mesures d'évaluation des modèles
Métriques de régression
Implémentation d'algorithmes d'apprentissage automatique avec Python
Avantages et inconvénients de le machine learning
Conclusion

Références
Introduction
Merci d'avoir acheté ce guide sur la data science et le machine
learning avec Python. L'une des premières questions que l'on se
pose est la suivante : qu'est-ce que la data science ? Il n'est pas
particulièrement facile de répondre à cette question, car le terme est
très répandu de nos jours, utilisé à peu près partout. Certains disent
que ce n'est rien de plus qu'une étiquette inutile, étant donné que la
science est de toute façon une affaire de données, tandis que
d'autres disent que ce n'est qu'un mot à la mode.
Cependant, beaucoup ne voient pas ou choisissent d'ignorer que la
data science est probablement la SEULE étiquette que l'on puisse
donner à l'ensemble des compétences interdisciplinaires qui
deviennent rapidement l'une des plus importantes dans les
applications. Il n'est pas possible de classer la data science dans une
seule discipline, c'est tout à fait vrai. Elle comprend trois domaines,
tous distincts et qui se chevauchent :

Statisticien - ces personnes sont capables de modéliser

des ensembles de données et de les résumer. Ces
compétences sont d'autant plus importantes aujourd'hui
que la taille des ensembles de données ne cesse
d'augmenter.
Informaticien - ces personnes conçoivent des
algorithmes et les utilisent pour stocker des données, les
traiter et les visualiser efficacement.
Expertise dans un domaine - s'apparente à une
formation classique dans un domaine, c'est-à-dire à une
connaissance d'expert. Elle est importante pour s'assurer
que les bonnes questions sont posées et que les
réponses sont placées dans le bon contexte.
Il ne serait donc pas négligent de ma part de vous encourager à
considérer la data science comme un ensemble de compétences que
vous pouvez acquérir et appliquer dans votre propre domaine
d'expertise, plutôt que comme quelque chose de nouveau que vous
devez apprendre à partir de zéro. Peu importe que vous examiniez
des images de microspores à la recherche de micro-organismes, que
vous prévoyiez les rendements des actions, que vous optimisiez les
publicités en ligne pour obtenir plus de clics ou tout autre domaine
dans lequel vous travaillez avec des données. Ce livre vous donnera
les bases dont vous avez besoin pour apprendre à poser les bonnes
questions dans votre domaine d'expertise.
À qui s'adresse ce livre
Ce livre s'adresse à ceux qui ont une expérience de la
programmation en Python et vise à les aider à améliorer leurs
compétences et à apprendre à utiliser le langage de programmation
qu'ils ont choisi pour aller beaucoup plus loin qu'auparavant. Il ne
s'adresse pas à ceux qui n'ont aucune expérience de Python ou de la
programmation, et je ne vous donnerai pas d'introduction au
langage.
Ce livre part du principe que vous avez déjà de l'expérience dans la
définition et l'utilisation de fonctions, l'appel de méthodes d'objets,
l'affectation de variables, le contrôle du déroulement du programme
et toutes les autres tâches de base de Python. Il est conçu pour
vous présenter les bibliothèques de data science en Python, telles
que NumPy, Pandas, Seaborn, Scikit-Learn, etc., en vous montrant
comment les utiliser pour stocker et manipuler des données et
obtenir des informations précieuses que vous pouvez utiliser dans
votre
travail.
Pourquoi utiliser Python ?
Au cours des dernières décennies, Python s'est imposé comme l'outil
le plus performant et le plus populaire pour l'analyse et la
visualisation des données, entre autres tâches scientifiques. Lorsque
Python a été conçu pour la première fois, il n'était certainement pas
destiné à la data science. Son utilisation dans ces domaines est
plutôt le fruit de l'ajout de paquets tiers, notamment :

NumPy - pour manipuler des données du même type

basées sur des tableaux
Pandas - pour manipuler différents types de données
basées sur des tableaux
SciPy - pour les tâches courantes en informatique
scientifique
 Matplotlib - pour des visualisations précises et de haute
qualité
Scikit-Learn - pour le machine learning
Et bien d'autres encore.
Python 2 vs. 3
Le code utilisé dans ce livre suit la syntaxe de Python 3. De
nombreuses améliorations ne sont pas rétrocompatibles avec Python
2, c'est pourquoi nous vous conseillons vivement d'installer la
dernière version de Python.
Bien que Python 3 ait été publié il y a environ 13 ans, son adoption a
été lente, en particulier dans les communautés scientifiques et de
développement web. Cela s'explique principalement par le fait que
les paquets tiers n'ont pas été rendus compatibles dès le départ.
Cependant, à partir de 2014, ces paquets ont commencé à être
disponibles dans des versions stables, et de plus en plus de
personnes ont commencé à adopter Python 3.
Que contient ce livre ?
Ce livre est divisé en cinq sections, chacune se concentrant sur un
domaine spécifique :

Première partie - Introduction à la data science et à le

machine learning
Deuxième partie : NumPy et son utilisation pour le
stockage et la manipulation de tableaux de données.
Troisième partie - se concentre sur Pandas et
comment l'utiliser pour stocker et manipuler des tableaux
de données en colonnes ou étiquetés.
Quatrième partie - Utilisation de Matplotlib et Seaborn
pour la visualisation de données
La cinquième partie, qui occupe environ la moitié de
l'ouvrage, est consacrée à le machine learning et
comprend une discussion sur les algorithmes.
La data science ne se résume pas à cela, mais il s'agit là des
principaux domaines sur lesquels vous devez vous concentrer
lorsque vous entamez votre parcours en data science et en
apprentissage automatique.
Installation
Étant donné que vous devriez avoir de l'expérience en Python, je
suppose que vous avez déjà Python sur votre machine. Cependant,
si ce n'est pas le cas, il y a plusieurs façons de l'installer, mais
Anaconda est la plus courante. Il en existe deux versions :

Miniconda - vous fournit l'interpréteur Python et conda,

un outil de ligne de commande.
Anaconda - fournit conda et Python, ainsi que de
nombreux autres paquets destinés à la data science. Il
s'agit d'une installation beaucoup plus volumineuse,
assurez-vous donc d'avoir beaucoup d'espace libre.
Il convient également de noter que les paquets dont il est question
dans ce livre peuvent être installés au-dessus de Miniconda, et qu'il
vous appartient donc de choisir la version que vous souhaitez
installer. Si vous choisissez Miniconda, vous pouvez utiliser la
commande suivante pour installer tous les paquets dont vous avez
besoin :
[~]$ conda install numpy pandas scikit-learn matplotlib
seaborn jupyter
Tous les paquets et outils peuvent être facilement installés à l'aide
de ce qui suit :
conda install nom du paquet
en veillant à taper le nom correct à la place de packagename.
Ne perdons pas de temps et plongeons dans notre introduction à la
data science et à le machine learning.
Première partie - Introduction à la data science
et à le machine learning
La définition de la data science indique qu'il s'agit d'un domaine de
recherche utilisé pour obtenir des informations utiles à partir de
données, et ce à l'aide d'une méthode théorique. En bref, la data
science est une combinaison de simulation, de technologie et de
gestion de marché.
Le machine learning est un peu différent. Il s'agit d'apprendre les
techniques de data science que les ordinateurs utilisent pour
apprendre à partir des données que nous leur fournissons. Nous
utilisons ces technologies pour obtenir des résultats sans avoir
besoin de programmer des lois spécifiques.
Le machine learning et la data science ont le vent en poupe de nos
jours et, bien que de nombreuses personnes utilisent ces termes de
manière interchangeable, ils sont différents. Décortiquons-les et
apprenons ce que nous devons savoir pour poursuivre le reste du
livre.
Qu'est-ce que la data science ?
La véritable signification de la data science réside dans l'analyse
approfondie d'énormes quantités de données contenues dans les
archives d'une entreprise. Il s'agit de déterminer d'où proviennent
ces données, si elles sont d'une qualité suffisante et si elles peuvent
être utilisées pour faire progresser l'entreprise à l'avenir.
Souvent, une organisation stocke ses données dans l'un des deux
formats suivants : non structuré ou organisé. L'examen des données
nous donne des indications utiles sur la dynamique des
consommateurs et du secteur, qui peuvent être utilisées pour donner
un avantage à l'entreprise par rapport à ses rivaux - cela se fait en
recherchant des modèles dans les données.
Les scientifiques des données savent comment transformer des
données brutes en quelque chose d'utilisable par une entreprise. Ils
savent repérer le codage algorithmique et traiter les données, grâce
à leur connaissance des statistiques et de l'apprentissage artificiel.
Certaines des plus grandes entreprises au monde utilisent l'analyse
de données, notamment Netflix, Amazon, les compagnies aériennes,
les services de prévention des fraudes, les soins de santé, etc.
Carrières en data science
La plupart des entreprises utilisent efficacement l'analyse des
données pour se développer, et les scientifiques des données sont
les plus demandés dans de nombreux secteurs. Si vous envisagez de
vous lancer dans la data science, voici quelques-unes des meilleures
carrières pour lesquelles vous pouvez vous former :

Le scientifique des données - étudie les tendances

dans les données afin de déterminer l'effet qu'elles
auront sur une entreprise. Sa tâche principale consiste à
déterminer l'importance des données et à les clarifier
pour que tout le monde puisse les comprendre.
L'analyste de données analyse les données pour
déterminer les tendances du secteur. Il aide à développer
une vision simpliste de la situation d'une entreprise dans
son secteur d'activité.
Ingénieur de données - souvent appelé l'épine dorsale
d'une entreprise, l'ingénieur de données crée des bases
de données pour stocker les données, les conçoit pour
une utilisation optimale et les gère. Leur travail consiste
à concevoir des pipelines de données, à s'assurer que les
données circulent correctement et à les acheminer là où
elles doivent l'être.
L'analyste en intelligence économique - parfois
appelé consultant en intelligence économique - étudie les
données afin d'améliorer les revenus et la productivité
d'une entreprise. Il s'agit d'un travail moins théorique et
plus scientifique, qui nécessite une compréhension
approfondie des machines courantes.
Quelle est l'importance de la data science ?
Dans le monde numérique d'aujourd'hui, un monde plein de
données, c'est l'un des emplois les plus importants. En voici
quelques raisons.

Tout d'abord, il permet aux entreprises de mieux

identifier leurs clients. Étant donné que les clients font
tourner les rouages d'une entreprise, ils déterminent
l'échec ou la réussite de cette dernière. Grâce à la data
science, les entreprises peuvent désormais communiquer
avec leurs clients de la bonne manière, de manière
différente selon les clients.
Deuxièmement, la data science permet à un produit de
raconter son histoire de manière divertissante et
convaincante, l'une des principales raisons pour
lesquelles la data science est si populaire. Les entreprises
et les marques peuvent utiliser les informations obtenues
grâce à la data science pour communiquer ce qu'elles
veulent que leurs clients sachent, ce qui permet de
renforcer les relations entre eux.
Ensuite, les résultats obtenus grâce à la data science
peuvent être utilisés dans à peu près tous les domaines,
de l'enseignement à la banque, des soins de santé au
tourisme, etc. La data science permet à une entreprise
de voir les problèmes et d'y répondre en conséquence.
Une entreprise peut utiliser l'analyse de données pour
mieux communiquer avec ses clients/consommateurs et
obtenir une meilleure vue d'ensemble de l'utilisation de
ses produits.
La data science gagne rapidement du terrain sur presque
tous les marchés et constitue désormais un élément
essentiel du développement des produits. Cela a conduit
à une augmentation du besoin de scientifiques des
données pour aider à gérer les données et trouver des
 réponses à certains des problèmes les plus complexes
auxquels une entreprise est confrontée.
Limites de la data science
La data science est peut-être l'une des carrières les plus lucratives
au monde à l'heure actuelle, mais elle n'est pas parfaite et présente
sa part d'inconvénients. Il ne serait pas juste de vanter les mérites
de la data science sans en souligner les limites :

La data science est incroyablement difficile à maîtriser.

En effet, il ne s'agit pas d'une discipline unique, mais
d'une combinaison de sciences de l'information, de
statistiques et de mathématiques, pour n'en citer que
quelques-unes. Il n'est pas facile de maîtriser chaque
discipline impliquée à un niveau compétent.
La data science exige également un niveau élevé de
connaissance du domaine. En fait, on peut dire qu'elle en
dépend. Si vous n'avez aucune connaissance en
informatique et en statistiques, vous aurez du mal à
résoudre n'importe quel problème lié à la data science.
La confidentialité des données est un enjeu majeur. Les
données font tourner le monde, et les data scientists
créent des solutions basées sur les données pour les
entreprises. Cependant, il y a toujours un risque que les
données qu'ils utilisent portent atteinte à la vie privée.
Une entreprise aura toujours accès à des données
sensibles et, si la protection des données est compromise
d'une manière ou d'une autre, cela peut conduire à des
violations de données.
Qu'est-ce que le machine learning ?
Le machine learning est un sous-ensemble de la data science, qui
permet aux machines d'apprendre des choses sans qu'un humain ait
besoin de les programmer. Le machine learning analyse les données
à l'aide d'algorithmes et prépare des prédictions possibles sans
intervention humaine. Il implique l'apprentissage par l'ordinateur
d'une série d'entrées sous forme de détails, d'observations ou de
commandes, et il est largement utilisé par des entreprises telles que
Google et Facebook.
Carrières en apprentissage automatique
Une fois que vous avez maîtrisé les compétences nécessaires, vous
pouvez prendre plusieurs directions. Voici trois de ces directions :

Ingénieur en apprentissage automatique - il s'agit

de l'une des carrières les plus prisées dans le monde de
la data science. Les ingénieurs utilisent généralement
des algorithmes d'apprentissage automatique pour
s'assurer que les applications et les systèmes
d'apprentissage automatique sont aussi efficaces que
possible. L'ingénieur en apprentissage automatique est
chargé de modeler les applications d'apprentissage
automatique, d'améliorer leur efficacité et leur efficience
en utilisant les résultats des tests pour les affiner et
effectuer des analyses statistiques. Python est l'un des
langages de programmation les plus utilisés pour réaliser
des expériences d'apprentissage automatique.
Les scientifiques PNL - ils s'occupent du traitement du
langage naturel et leur travail consiste à s'assurer que les
machines peuvent interpréter les langues naturelles. Ils
conçoivent et mettent au point des logiciels et des
ordinateurs qui apprennent les habitudes de langage de
l'homme et convertissent les mots prononcés en
différentes langues. Leur objectif est de faire en sorte
que les ordinateurs comprennent les langues humaines
de la même manière que nous, et deux des meilleurs
exemples sont les applications DuoLingo et Grammarly.
Développeur/ingénieur en logiciels - ils développent
des programmes informatiques intelligents et se
spécialisent dans le machine learning et l'intelligence
artificielle. Leur principal objectif est de créer des
 algorithmes qui fonctionnent efficacement et de les
mettre en œuvre de la bonne manière. Ils conçoivent des
fonctions complexes, planifient des organigrammes, des
graphiques, des mises en page, des documentations de
produits, des tableaux et d'autres aides visuelles. Ils sont
également chargés de composer des codes et de les
évaluer, de créer des spécifications techniques, de mettre
à jour des programmes et de les gérer, etc.
Quelle est l'importance de le machine learning ?
Le machine learning est un monde en constante évolution et, plus il
évolue rapidement, plus son importance est grande et plus la
demande augmente. L'une des principales raisons pour lesquelles les
scientifiques des données ne peuvent pas se passer de le machine
learning est la suivante : "des prévisions de grande valeur qui
orientent les décisions et les comportements intelligents en temps
réel, sans interférence humaine".
Il devient rapidement populaire pour interpréter d'énormes quantités
de données et aider à automatiser les tâches que les scientifiques
des données effectuent quotidiennement. On peut dire que le
machine learning a changé la façon dont nous extrayons les données
et les visualisons. Étant donné que les entreprises dépendent de plus
en plus des données de nos jours, les décisions fondées sur les
données aident à déterminer si une entreprise a des chances de
réussir ou de se laisser distancer par ses concurrents.
Limites de le machine learning
Comme la data science, le machine learning a aussi ses limites, dont
voici quelques-unes des plus importantes :

Les algorithmes doivent stocker d'énormes quantités de

données d'apprentissage. Plutôt que d'être programmé,
un programme d'IA est éduqué. Cela signifie qu'il a
besoin de grandes quantités de données pour apprendre
à faire quelque chose et l'exécuter à un niveau humain.
 Dans de nombreux cas, ces énormes ensembles de
données ne sont pas faciles à générer pour des
utilisations spécifiques, malgré la rapidité avec laquelle
les données sont produites.

Les réseaux neuronaux apprennent à identifier des objets,

par exemple des images, en étant formés sur des quantités
massives de données étiquetées dans le cadre d'un
processus connu sous le nom d'apprentissage supervisé.
Quelle que soit son importance, toute modification de
l'affectation nécessite une nouvelle collecte de données, qui
doit également être préparée. Il est juste de dire qu'un
réseau neuronal ne peut pas vraiment fonctionner à un
niveau d'intelligence humaine en raison de la force brute
nécessaire pour y parvenir - cela changera à l'avenir.

Le machine learning nécessite trop de temps pour

marquer les données d'apprentissage. L'IA utilise
l'apprentissage supervisé sur une série de réseaux
neuronaux profonds. Il est essentiel d'étiqueter les
données au cours de la phase de traitement, ce qui est
fait à l'aide d'attributs d'objectifs prédéfinis tirés de
données historiques. Le marquage des données est
l'étape où les données sont nettoyées et triées pour
permettre aux réseaux neuronaux de travailler dessus.

Il ne fait aucun doute que de grandes quantités

d'informations étiquetées sont nécessaires pour
l'apprentissage profond et, bien que cela ne soit pas
particulièrement difficile à comprendre, ce n'est pas le travail
le plus facile à réaliser. Si des résultats non étiquetés sont
utilisés, le programme ne peut pas apprendre à devenir plus
intelligent.

Les algorithmes d'IA ne fonctionnent pas toujours bien

ensemble. Malgré quelques avancées récentes, un
 modèle d'IA ne peut généraliser une situation que si on
lui demande de faire quelque chose qu'il n'a pas fait lors
de la formation. Les modèles d'IA ne peuvent pas
toujours déplacer des données entre des groupes de
conditions, ce qui implique que tout ce qui est accompli
par un paradigme avec un cas d'utilisation spécifique ne
peut être pertinent que pour ce cas. Par conséquent, les
entreprises doivent utiliser des ressources
supplémentaires pour maintenir les modèles formés et
en former de nouveaux, même si les cas d'utilisation sont
souvent les mêmes.
Data science et apprentissage automatique
Les data scientists doivent comprendre en profondeur l'analyse des
données, tout en ayant d'excellentes capacités de programmation.
En fonction de l'entreprise qui recrute le data scientist, il existe une
gamme d'expertise et les compétences peuvent être divisées en
deux catégories différentes :
Compétences techniques
Vous devez vous spécialiser :

Algèbre
Ingénierie informatique
Statistiques
Les candidats doivent également être compétents dans les domaines
suivants

Programmation informatique
Outils analytiques, tels que R, Spark, Hadoop et SAS
Travailler avec des données non structurées obtenues à
partir de différents réseaux
Compétences non techniques
La plupart des compétences d'un scientifique des données ne sont
pas techniques et comprennent :

Un bon sens des affaires

La capacité d'interagir
Intuition des données
Les experts en apprentissage automatique doivent également
maîtriser certaines compétences, notamment :

Probabilités et statistiques - l'expérience théorique

est étroitement liée à la manière dont vous comprenez
les algorithmes, tels que Naïve Bayes. Markov caché,
mélange gaussien, et bien d'autres. L'expérience des
chiffres et du hasard facilite la compréhension de ces
algorithmes.
L'évaluation et la modélisation des données -
l'évaluation fréquente de l'efficacité des modèles est un
élément essentiel du maintien de la fiabilité des mesures
dans le domaine de le machine learning. La classification,
la régression et d'autres méthodes sont utilisées pour
évaluer la cohérence et les taux d'erreur des modèles,
ainsi que les plans d'évaluation, et la connaissance de
ces méthodes est essentielle.
Algorithmes d'apprentissage automatique - il
existe des tonnes d'algorithmes d'apprentissage
automatique et vous devez connaître leur
fonctionnement pour savoir lequel utiliser pour chaque
scénario. Vous devrez connaître la programmation
quadratique, la descente de gradient, l'optimisation
convexe, les équations différentielles partielles et
d'autres sujets similaires.
Langages de programmation - vous devrez avoir de
l'expérience en programmation dans un ou plusieurs
langages - Python, R, Java, C++, etc.
 Techniques de traitement du signal - l'extraction de
caractéristiques est l'un des facteurs les plus critiques de
le machine learning. Vous devrez connaître certains
algorithmes de traitement spécialisés, tels que les
shearlets, les bandlets, les curvelets et les contourlets.
La data science est un secteur interdisciplinaire qui utilise d'énormes
quantités de données pour obtenir des informations. Parallèlement,
le machine learning est un sous-ensemble passionnant de la data
science, utilisé pour encourager les machines à apprendre par elles-
mêmes à partir des données fournies.
Ces deux types d'outils offrent un grand nombre de cas d'utilisation,
mais ils ont aussi leurs limites. La data science peut être forte, mais,
comme toute chose, elle n'est efficace que si l'on utilise une
formation appropriée et des données de la meilleure qualité.
Passons maintenant à l'utilisation de Python pour la data science.
Ensuite, nous vous présenterons NumPy.
Deuxième partie - Présentation de NumPy
NumPy est l'une des bibliothèques Python les plus élémentaires et,
au fil du temps, vous en viendrez à l'utiliser pour toutes sortes de
tâches liées à la data science, qu'il s'agisse de mathématiques
simples ou de classification d'images. NumPy peut traiter
efficacement des ensembles de données de toutes tailles, même les
plus grands, et une bonne maîtrise de son fonctionnement est
essentielle à votre réussite dans le domaine de la data science.
Tout d'abord, nous verrons ce qu'est NumPy et pourquoi vous
devriez l'utiliser plutôt que d'autres méthodes, telles que les listes
Python. Ensuite, nous examinerons certaines de ses opérations pour
comprendre exactement comment l'utiliser - ce qui comprendra de
nombreux exemples de code à étudier.
Qu'est-ce que la bibliothèque NumPy ?
NumPy est une version abrégée de Numerical Python, et c'est, de
loin, la bibliothèque la plus scientifique de Python. Elle prend en
charge les objets de type tableau multidimensionnel, ainsi que tous
les outils nécessaires pour travailler avec ces tableaux. De
nombreuses autres bibliothèques populaires, telles que Pandas,
Scikit-Learn et Matplotlib, sont toutes basées sur NumPy.
Qu'est-ce qu'un tableau ? Si vous connaissez les bases de Python,
vous savez qu'un tableau est une collection de valeurs ou d'éléments
à une ou plusieurs dimensions. Un tableau à une dimension est un
vecteur, tandis qu'un tableau à deux dimensions est une matrice.
Les tableaux NumPy sont connus sous le nom de tableaux à N
dimensions, également appelés ndarrays, et les éléments qu'ils
stockent sont du même type et de la même taille. Ils sont très
performants, efficaces pour les opérations de données et constituent
une forme de stockage efficace lorsque les tableaux deviennent plus
grands.
Lorsque vous installez Anaconda, vous recevez NumPy avec, mais
vous pouvez l'installer sur votre machine séparément en tapant la
commande suivante dans le terminal :
 pip install numpy
Une fois que vous avez fait cela, la bibliothèque doit être importée,
en utilisant cette commande :
import numpy as np
NOTE
np est l'abréviation courante de NumPy
Listes Python et tableaux NumPy
Les personnes habituées à utiliser Python se demanderont
probablement pourquoi nous utiliserions les tableaux NumPy alors
que nous disposons des excellentes listes Python. Ces listes agissent
déjà comme des tableaux pour stocker différents types d'éléments,
après tout, alors pourquoi changer les choses ?
La réponse à cette question réside dans la manière dont les objets
sont stockés en mémoire par Python.
Les objets Python sont des pointeurs vers des emplacements de
mémoire où les détails de l'objet sont stockés. Ces détails
comprennent la valeur et le nombre d'octets. Ces informations
supplémentaires expliquent en partie pourquoi Python est considéré
comme un langage à typage dynamique, mais elles ont un coût
supplémentaire. Ce coût devient évident lorsque de grandes
collections d'objets, telles que des tableaux, sont stockées.
Une liste Python est un tableau de pointeurs. Chaque pointeur
pointe vers un emplacement spécifique contenant des informations
relatives à l'élément. En termes de calcul et de mémoire, cela
représente un coût supplémentaire important. Pour aggraver les
choses, lorsque tous les objets stockés sont du même type, la
plupart des informations supplémentaires deviennent redondantes,
ce qui signifie un coût supplémentaire sans raison.
Les tableaux NumPy permettent de résoudre ce problème. Ces
tableaux ne stockent que des objets de même type, autrement dit
des objets homogènes. De cette manière, le stockage et la
manipulation du tableau sont beaucoup plus efficaces, et nous
pouvons voir cette différence clairement lorsqu'il y a de grandes
quantités d'éléments dans le tableau, par exemple des millions
d'éléments. Nous pouvons également effectuer des opérations par
élément sur les tableaux NumPy, ce que nous ne pouvons pas faire
avec une liste Python.
C'est pourquoi nous préférons utiliser ces tableaux plutôt que des
listes lorsque nous voulons effectuer des opérations mathématiques
sur de grandes quantités de données.
Comment créer un tableau NumPy
Tableau nd de base
Les tableaux NumPy sont simples à créer, quels qu'ils soient et quelle
que soit la complexité du problème à résoudre. Nous commencerons
par le tableau NumPy le plus basique, le ndarray.
Tout ce dont vous avez besoin est la méthode np.array() suivante,
en veillant à transmettre les valeurs du tableau sous forme de liste :
np.array([1,2,3,4])
Le résultat est le suivant :
array([1, 2, 3, 4])
Ici, nous avons inclus des valeurs entières et l'argument dtype est
utilisé pour spécifier le type de données :
np.array([1,2,3,4],dtype=np.float32)
Le résultat est le suivant :
array([1., 2., 3., 4.], dtype=float32)
Comme on ne peut inclure des types de données homogènes dans
un tableau NumPy que si les types de données ne correspondent
pas, les valeurs sont remontées :
 np.array([1,2.0,3,4])
Le résultat est le suivant :
array([1., 2., 3., 4.])
Dans cet exemple, les valeurs entières sont converties en valeurs
flottantes.
Vous pouvez également créer des tableaux multidimensionnels :
np.array([[1,2,3,4],[5,6,7,8]])
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
Cela crée un tableau à deux dimensions contenant des valeurs.
NOTE
L'exemple ci-dessus est une matrice 2 x 4. Une matrice est un
tableau rectangulaire contenant des nombres. Sa forme est N x M -
N indique le nombre de lignes et M le nombre de colonnes.
Un tableau de zéros
Vous pouvez également créer des tableaux ne contenant que des
zéros. Cela se fait avec la méthode np.zeros(), en s'assurant que
vous transmettez la forme du tableau que vous souhaitez :
np.zeros(5)
array([0., 0., 0., 0., 0.])
Ci-dessus, nous avons créé un tableau à une dimension, tandis que
le tableau ci-dessous est un tableau à deux dimensions :
np.zeros((2,3))
array([[0., 0., 0.],
[0., 0., 0.]])
Un éventail de personnes
La méthode np.ones() est utilisée pour créer un tableau contenant
des 1 :
np.ones(5,dtype=np.int32)
array([1, 1, 1, 1, 1])
Utilisation de nombres aléatoires dans un tableau
numérique
La méthode np.random.rand() est couramment utilisée pour créer
des ndarray de forme donnée contenant des valeurs aléatoires de
[0,1] :
# aléatoire
np.random.rand(2,3)
array([[0.95580785, 0.98378873, 0.65133872],
[0.38330437, 0.16033608, 0.13826526]])
Votre choix de tableau
Vous pouvez même créer des tableaux avec n'importe quelle valeur
grâce à la méthode np.full(), en vous assurant que la forme du
tableau que vous souhaitez est transmise avec la valeur désirée :
np.full((2,2),7)
array([[7, 7],
[7, 7]])
NumPy IMatrix
La méthode np.eye() est une autre bonne méthode qui renvoie des
1 sur la diagonale et des 0 partout ailleurs. Plus connue sous le nom
de matrice d'identité, il s'agit d'une matrice carrée de forme N x N,
ce qui signifie qu'il y a le même nombre de lignes que de colonnes.
Voici une matrice IM 3 x 3 :
 # matrice d'identité
np.eye(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Toutefois, vous pouvez également modifier la diagonale où les
valeurs sont des 1. Elle pourrait se situer au-dessus de la diagonale
primaire :
# n'est pas une matrice d'identité
np.eye(3,k=1)
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
Ou en dessous :
np.eye(3,k=-2)
array([[0., 0., 0.],
[0., 0., 0.],
[1., 0., 0.]])
NOTE
Une matrice ne peut être une matrice IM que si les 1 apparaissent
sur la diagonale principale, pas ailleurs.
Tableaux nd à espacement régulier
La méthode np.arange() fournit des tableaux de nombres
régulièrement espacés :
np.arange(5)
 array([0, 1, 2, 3, 4])
Nous pouvons définir explicitement le début et la fin ainsi que la
taille du pas de l'intervalle en passant un argument pour chaque
valeur.
NOTE
Nous définissons l'intervalle comme [début, fin] et le nombre final
n'est pas ajouté au tableau :
np.arange(2,10,2)
array([2, 4, 6, 8])
Comme nous avons défini la taille de l'étape à 2, nous avons obtenu
les éléments alternatifs en conséquence. L'élément final était 10, et il
n'a pas été inclus.
Une fonction similaire est appelée np.linspace(), qui prend un
argument sous la forme du nombre d'échantillons que nous voulons
dans l'intervalle.
NOTE
Cette fois, le dernier numéro sera inclus dans le résultat.
np.linspace(0,1,5)
array([0. , 0.25, 0.5 , 0.75, 1. ])
Voilà comment créer une variété de tableaux avec NumPy, mais il y a
autre chose d'aussi important : la forme du tableau.
Mise en forme et remise en forme d'un tableau
NumPy
Lorsque votre ndarray a été créé, vous devez vérifier trois choses :

Nombre d'axes du tableau nd

La forme du tableau
 La taille du tableau
Dimensions des tableaux NumPy
Il est facile de déterminer le nombre d'axes ou de dimensions d'un
tableau nd à l'aide d'un attribut appelé ndims :
# Nombre d'axes
a = np.array([[5,10,15],[20,25,20]])
print('Tableau :','\n',a)
print('Dimensions :','\n',a.ndim)
Array :
[[ 5 10 15]
[20 25 20]]
Dimensions :
2
Ici, nous avons un tableau à deux dimensions avec deux lignes et
trois colonnes.
Forme des tableaux NumPy
La forme du tableau est un attribut de tableau indiquant le nombre
de lignes avec des éléments pour chacune des dimensions. La forme
peut être indexée de manière à ce que le résultat indique la valeur
de chaque dimension :
a = np.array([[1,2,3],[4,5,6]])
print('Tableau :','\n',a)
print('Forme :','\n',a.shape)
print('Lignes = ',a.shape[0])
print('Colonnes = ',a.shape[1])
 Array :
[[1 2 3]
[4 5 6]]
Forme :
(2, 3)
Lignes = 2
Colonnes = 3
Taille du réseau
L'attribut size vous indique le nombre de valeurs de votre tableau en
multipliant le nombre de lignes par le nombre de colonnes :
# Taille du tableau
a = np.array([[5,10,15],[20,25,20]])
print('Taille du tableau :',a.size)
print('Détermination manuelle de la taille du tableau
:',a.shape[0]*a.shape[1])
Taille du tableau : 6
Détermination manuelle de la taille du tableau : 6
Remodelage d'un tableau
Vous pouvez utiliser la méthode np.reshape() pour remodeler votre
ndarray sans modifier les données qu'il contient :
# reshape
a = np.array([3,6,9,12])
np.reshape(a,(2,2))
array([[ 3, 6],
 [ 9, 12]])
Nous avons transformé ce tableau unidimensionnel en un tableau
bidimensionnel.
Lorsque vous remodelez votre tableau et que vous n'êtes pas sûr de
la forme de l'un des axes, entrez -1. Lorsque NumPy verra -1, il
calculera la forme automatiquement :
a = np.array([3,6,9,12,18,24])
print('Trois lignes :','\n',np.reshape(a,(3,-1)))
print('Trois colonnes :','\n',np.reshape(a,(-1,3)))
Trois rangs :
[[ 3 6]
[ 9 12]
[18 24]]
Trois colonnes :
[[ 3 6 9]
[12 18 24]]
Aplatissement des tableaux
Il peut arriver que vous souhaitiez réduire un tableau
multidimensionnel en un tableau unidimensionnel. Il existe deux
méthodes pour cela : flatten() et ravel() :
a = np.ones((2,2))
b = a.flatten()
c = a.ravel()
print('Forme originale :', a.shape)
print('Tableau :','\n', a)
 print('Forme après aplatissement :',b.shape)
print('Tableau :','\n', b)
print('Forme après le voyage :',c.shape)
print('Tableau :','\n', c)
Forme originale : (2, 2)
Array :
[[1. 1.]
[1. 1.]]
Forme après aplatissement : (4,)
Array :
[1. 1. 1. 1.]
Forme après le ravel : (4,)
Array :
[1. 1. 1. 1.]
Cependant, il existe une différence essentielle entre les deux
méthodes - flatten() renvoie une copie de l'original alors que ravel()
ne renvoie qu'une référence. Si le tableau retourné par revel() subit
des modifications, le tableau original les reflétera, ce qui n'est pas le
cas avec la méthode flatten().
b[0] = 0
print(a)
[[1. 1.]
[1. 1.]]
Le tableau original n'indiquait pas les changements.
c[0] = 0
 print(a)
[[0. 1.]
[1. 1.]]
Mais celle-ci a montré les changements.
Une copie profonde du ndarray est créée par flatten(), tandis qu'une
copie superficielle est créée par ravel().
Un nouveau ndarray est créé dans une copie profonde, stockée en
mémoire, avec l'objet flatten() qui pointe vers cet emplacement en
mémoire. C'est pourquoi les modifications ne se reflètent pas dans
l'original.
Une référence à l'emplacement d'origine est renvoyée par une copie
superficielle, ce qui signifie que l'objet renvoyé par ravel() pointe
vers l'emplacement de mémoire où l'objet d'origine est stocké. Cela
signifie que les changements seront reflétés dans l'original.
Transposition d'un tableau numérique
La méthode transpose() est une méthode de remodelage qui prend
le tableau d'entrée et échange les valeurs des lignes avec celles des
colonnes et vice versa :
a = np.array([[1,2,3],
[4,5,6]])
b = np.transpose(a)
print('Original', '\N', 'Forme',a.shape, '\N',a)
print('Expand along columns:','\n','Shape',b.shape,'\n',b)
Original
Forme (2, 3)
[[1 2 3]
[4 5 6]]
 Développer le long des colonnes :
Forme (3, 2)
[[1 4]
[2 5]
[3 6]]
Lorsque vous transposez un tableau de 2 x 3, vous obtenez un
tableau de 3 x 2.
Expansion et compression des tableaux NumPy
Le développement d'un tableau nd implique l'ajout de nouveaux
axes. Pour ce faire, on utilise la méthode expand_dims(), à laquelle
on transmet le tableau et l'axe que l'on souhaite développer :
# étendre les dimensions
a = np.array([1,2,3])
b = np.expand_dims(a,axis=0)
c = np.expand_dims(a,axis=1)
print('Original:', '\N', 'Shape',a.shape, '\N',a)
print('Expand along columns:','\n','Shape',b.shape,'\n',b)
print('Expand along rows:','\n','Shape',c.shape,'\n',c)
Original :
Forme (3,)
[1 2 3]
Développer le long des colonnes :
Forme (1, 3)
[[1 2 3]]
 S'étendre le long des rangées :
Forme (3, 1)
[[1]
[2]
[3]]
Toutefois, si vous souhaitez réduire l'axe, vous devez utiliser la
méthode squeeze(). Cette méthode supprime un axe avec une
entrée. Ainsi, si vous avez une matrice de 2 x 2 x 1, la troisième
dimension est supprimée.
# squeeze
a = np.array([[[1,2,3],
[4,5,6]]])
b = np.squeeze(a, axis=0)
print('Original', '\N', 'Forme',a.shape, '\N',a)
print('Tableau de compression:', '\N', 'Forme',b.shape, '\N',b)
Original
Forme (1, 2, 3)
[[[1 2 3]
[4 5 6]]]
Tableau de compression :
Forme (2, 3)
[[1 2 3]
[4 5 6]]
Si vous avez une matrice 2 x 2 et que vous essayez d'utiliser
squeeze(), vous obtiendrez une erreur :
 # squeeze
a = np.array([[1,2,3],
[4,5,6]])
b = np.squeeze(a, axis=0)
print('Original', '\N', 'Forme',a.shape, '\N',a)
print('Tableau de compression:', '\N', 'Forme',b.shape,
'\N',b)cv
Le message d'erreur indique que le problème se situe à la ligne 3 et
contient le message suivant :
ValueError : cannot select an axis to squeeze out which has
size not equal to one (erreur de valeur : impossible de
sélectionner un axe dont la taille n'est pas égale à un)
Indexer et découper un tableau NumPy
Nous savons comment créer des tableaux NumPy et comment
modifier leur forme et leur taille. Nous allons maintenant voir
comment utiliser l'indexation et le découpage pour extraire des
valeurs.
Découpage d'un tableau unidimensionnel
Lorsque vous découpez un tableau, vous récupérez les éléments
d'une "tranche" spécifiée du tableau. Vous devez fournir les points
de départ et d'arrivée comme ceci [start : end], mais vous pouvez
aussi aller un peu plus loin et fournir une taille de pas. Supposons
que l'élément alternatif du tableau soit imprimé. Dans ce cas, votre
taille de pas serait définie à 2, ce qui signifie que vous voulez
l'élément à 2 pas de l'index actuel. Cela ressemblerait à [start :
end:step-size] :
a = np.array([1,2,3,4,5,6])
print(a[1:5:2])
 [2 4]
Notez que le dernier élément n'a pas été pris en compte - lorsque
vous découpez un tableau, seul l'indice de départ est pris en compte,
et non l'indice de fin.
Vous pouvez contourner ce problème en ajoutant la valeur
immédiatement supérieure à votre valeur finale :
a = np.array([1,2,3,4,5,6])
print(a[1:6:2])
[2 4 6]
Si l'index de départ ou de fin n'est pas spécifié, la valeur par défaut
sera 0 pour l'index de départ et la taille du tableau pour l'index de
fin, avec une taille de pas par défaut de 1 :
a = np.array([1,2,3,4,5,6])
print(a[:6:2])
print(a[1::2])
print(a[1:6 :])
[1 3 5]
[2 4 6]
[2 3 4 5 6]
Découpage d'un tableau bidimensionnel
Les tableaux bidimensionnels comportent à la fois des colonnes et
des lignes, de sorte qu'il n'est pas particulièrement facile de les
découper. Cependant, une fois que vous aurez compris comment
procéder, vous serez en mesure de découper n'importe quel tableau.
Avant de découper un tableau à deux dimensions, nous devons
comprendre comment en extraire des éléments :
a = np.array([[1,2,3],
 [4,5,6]])
print(a[0,0])
print(a[1,2])
print(a[1,0])
1
6
4
Ici, nous avons identifié l'élément pertinent en fournissant les
valeurs de la ligne et de la colonne. Dans un tableau
unidimensionnel, il suffit de fournir la valeur de la colonne car le
tableau n'a qu'une seule ligne.
Pour découper un tableau à deux dimensions, il faut mentionner une
tranche pour la colonne et pour la ligne :
a = np.array([[1,2,3],[4,5,6]])
# imprimer les valeurs de la première ligne
print('Valeurs de la première ligne :','\n',a[0:1, :])
# avec pas de taille pour les colonnes
print('Alternate values from first row:','\n',a[0:1,::2])
#
print('Valeurs de la deuxième colonne :','\n',a[ :,1::2])
print('Valeurs arbitraires :','\n',a[0:1,1:3])
Valeurs de la première ligne :
[[1 2 3]]
Valeurs alternatives de la première ligne :
[[1 3]]
 Valeurs de la deuxième colonne :
[[2]
[5]]
Valeurs arbitraires :
[[2 3]]
Découpage d'un tableau tridimensionnel
Nous n'avons pas encore étudié les tableaux tridimensionnels,
voyons donc à quoi ils ressemblent :
a = np.array([[[1,2],[3,4],[5,6]],# tableau du premier axe
[[7,8],[9,10],[11,12]],# tableau du deuxième axe
[[13,14],[15,16],[17,18]])# tableau du troisième axe
# Tableau 3-D
print(a)
[[[ 1 2]
[ 3 4]
[ 5 6]]

[[ 7 8]
[ 9 10]
[11 12]]

[[13 14]
[15 16]
[17 18]]]
Les tableaux tridimensionnels n'ont pas seulement des lignes et des
colonnes. Ils ont également des axes de profondeur, c'est-à-dire
qu'un tableau bidimensionnel est empilé derrière un autre. Lorsqu'un
tableau tridimensionnel est découpé, vous devez spécifier le tableau
bidimensionnel à découper. Il est généralement listé en premier dans
l'index :
# Valeur
print('Premier tableau, première ligne, première colonne
:','\n',a[0,0,0])
print('Premier tableau dernière colonne :','\n',a[0, :,1])
print('Deux premières lignes pour les deuxième et troisième
tableaux :','\n',a[1 :,0:2,0:2])
Premier tableau, première ligne, première colonne :
1
Premier tableau dernière colonne :
[2 4 6]
Deux premières lignes pour les deuxième et troisième
tableaux :
[[[ 7 8]
[ 9 10]]

[[13 14]
[15 16]]]
Si vous souhaitez que les valeurs soient répertoriées dans un tableau
à une dimension, vous pouvez utiliser la méthode flatten() :
print('Printing as a single array :','\n',a[1 :,0:2,0:2].flatten())
Impression sous forme de tableau unique :
 [ 7 8 9 10 13 14 15 16]
Tranchage négatif
Vous pouvez également utiliser le découpage négatif sur votre
tableau. Cela permet d'imprimer les éléments à partir de la fin, au
lieu de commencer au début :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print(a[ :,-1])
[ 5 10]
Les valeurs finales de chaque ligne ont été imprimées, mais si nous
voulions que les valeurs soient extraites à partir de la fin, il faudrait
fournir un pas-à-pas négatif. Si ce n'est pas le cas, on obtient une
liste vide.
print(a[ :,-1:-3:-1])
[[ 5 4]
[10 9]]
Cela dit, la logique de découpage est la même - vous n'obtiendrez
pas l'indice final dans le résultat.
Vous pouvez également utiliser le découpage négatif si vous
souhaitez que le tableau original soit inversé :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print('Tableau original :','\n',a)
print('Tableau inversé :','\n',a[::-1,::-1])
Réseau original :
[[ 1 2 3 4 5]
 [ 6 7 8 9 10]]
Tableau inversé :
[[10 9 8 7 6]
[ 5 4 3 2 1]]
Et un ndarray peut être inversé à l'aide de la méthode flip() :
a = np.array([[1,2,3,4,5],
[6,7,8,9,10]])
print('Tableau original :','\n',a)
print('Tableau inversé verticalement :','\n',np.flip(a,axis=1))
print('Tableau inversé horizontalement
:','\n',np.flip(a,axis=0))
Réseau original :
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
Tableau inversé verticalement :
[[ 5 4 3 2 1]
[10 9 8 7 6]]
Réseau inversé horizontalement :
[[ 6 7 8 9 10]
[ 1 2 3 4 5]]
Empiler et concaténer des tableaux NumPy
Les tableaux existants peuvent être combinés pour créer de
nouveaux tableaux, et ce de deux manières :
 Combiner verticalement des tableaux le long des lignes.
Cette opération s'effectue à l'aide de la méthode vstack()
et augmente le nombre de lignes du tableau renvoyé.
Combine horizontalement les tableaux le long des
colonnes. Cette opération s'effectue à l'aide de la
méthode hstack() et augmente le nombre de colonnes
du tableau renvoyé.
a = np.arange(0,5)
b = np.arange(5,10)
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Vertical stacking :','\n',np.vstack((a,b)))
print('Empilement horizontal :','\n',np.hstack((a,b)))
Array 1 :
[0 1 2 3 4]
Réseau 2 :
[5 6 7 8 9]
Empilage vertical :
[[0 1 2 3 4]
[5 6 7 8 9]]
Empilage horizontal :
[0 1 2 3 4 5 6 7 8 9]
Il convient de noter que l'axe le long duquel le tableau est combiné
doit avoir la même taille. Si ce n'est pas le cas, une erreur est
générée :
a = np.arange(0,5)
b = np.arange(5,9)
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Vertical stacking :','\n',np.vstack((a,b)))
print('Empilement horizontal :','\n',np.hstack((a,b)))
Le message d'erreur indique que l'erreur se situe à la ligne 5 et se lit
comme suit :
ValueError : toutes les dimensions du tableau d'entrée pour
l'axe de concaténation doivent correspondre exactement,
mais le long de la dimension 1, le tableau à l'index 0 a une
taille de 5 et le tableau à l'index 1 a une taille de 4.
Vous pouvez également utiliser la méthode dstack() pour combiner
des tableaux en combinant les éléments un index à la fois et en les
empilant sur l'axe de profondeur.
a = [[1,2],[3,4]]
b = [[5,6],[7,8]]
c = np.dstack((a,b))
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Dstack :','\n',c)
print(c.shape)
Array 1 :
[[1, 2], [3, 4]]
Réseau 2 :
[[5, 6], [7, 8]]
 Dstack :
[[[1 5]
[2 6]]

[[3 7]
[4 8]]]
(2, 2, 2)
Vous pouvez empiler des tableaux pour combiner d'anciens tableaux
en un nouveau, mais vous pouvez également joindre des tableaux
passés sur un axe existant à l'aide de la méthode concatenate() :
a = np.arange(0,5).reshape(1,5)
b = np.arange(5,10).reshape(1,5)
print('Tableau 1 :','\n',a)
print('Tableau 2 :','\n',b)
print('Concatenate along rows
:','\n',np.concatenate((a,b),axis=0))
print('Concatenate along columns
:','\n',np.concatenate((a,b),axis=1))
Array 1 :
[[0 1 2 3 4]]
Réseau 2 :
[[5 6 7 8 9]]
Concaténation le long des lignes :
[[0 1 2 3 4]
[5 6 7 8 9]]
 Concaténation le long des colonnes :
[[0 1 2 3 4 5 6 7 8 9]]
Toutefois, cette méthode présente un inconvénient majeur : le
tableau d'origine doit contenir l'axe le long duquel vous combinez,
sinon vous obtiendrez une erreur.
La méthode append() peut être utilisée pour ajouter de nouveaux
éléments à la fin d'un ndarray. Cette méthode est très utile si vous
souhaitez ajouter de nouvelles valeurs à un ndarray existant :
# append values to ndarray
a = np.array([[1,2],
[3,4]])
np.append(a,[[5,6]], axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
Diffusion dans les tableaux NumPy
Si les ndarrays présentent de nombreuses caractéristiques
intéressantes, l'une des meilleures est sans aucun doute la diffusion.
Elle permet d'effectuer des opérations mathématiques entre des
ndarrays de tailles différentes ou entre un simple nombre et un
ndarray.
Essentiellement, la diffusion étire des ndarrays plus petits pour qu'ils
correspondent à la forme du plus grand.
a = np.arange(10,20,2)
b = np.array([[2],[2]])
print('Adding two different size arrays :','\n',a+b)
 print('Multiplier un ndarray et un nombre :',a*2)
Ajout de deux tableaux de taille différente :
[[12 14 16 18 20]
[12 14 16 18 20]]
Multiplication d'un ndarray et d'un nombre : [20 24 28 32
36]
Cela revient à faire une copie ou à étirer le nombre ou le scalaire [2,
2, 2] pour qu'il corresponde à la forme du ndarray, puis à effectuer
une opération élémentaire sur ce nombre ou ce scalaire. Cependant,
aucune copie n'est réellement effectuée - c'est simplement la
meilleure façon d'imaginer le fonctionnement de la diffusion.
Pourquoi est-ce si utile ?
Parce que la multiplication d'un tableau contenant une valeur
scalaire est plus efficace que la multiplication d'un autre tableau.
NOTE
Une paire de ndarrays doit être compatible pour être diffusée
ensemble. Cette compatibilité se produit lorsque

Les deux ndarrays ont des dimensions identiques

Un tableau nd a une dimension de 1, qui est ensuite
diffusée pour répondre aux exigences de taille du tableau
plus grand.
S'ils ne sont pas compatibles, une erreur est générée :
a = np.ones((3,3))
b = np.array([2])
a+b
array([[3., 3., 3.],
 [3., 3., 3.],
[3., 3., 3.]])
Dans ce cas, nous avons hypothétiquement étiré le deuxième
tableau à une forme de 3 x 3 avant de calculer le résultat.
NumPy Ufuncs
Si vous connaissez un tant soit peu Python, vous savez qu'il est
dynamiquement typé. Cela signifie que Python n'a pas besoin de
connaître son type de données au moment où une variable est
assignée, car il le déterminera automatiquement au moment de
l'exécution. Cependant, bien que cela garantisse un code plus
propre, cela ralentit un peu les choses.
Ce problème tend à s'aggraver lorsque Python doit effectuer de
nombreuses opérations à plusieurs reprises, comme l'addition de
deux tableaux. Python doit vérifier le type de données de chaque
élément à chaque fois qu'une opération doit être effectuée, ce qui
ralentit les choses, mais nous pouvons y remédier en utilisant les
ufuncs.
NumPy accélère les choses grâce à ce qu'on appelle la vectorisation.
Sur un ndarray en code compilé, la vectorisation effectue une
opération sur chaque élément à tour de rôle. Ainsi, il n'est pas
nécessaire de déterminer à chaque fois le type de données des
éléments, ce qui accélère les choses.
Une ufunc est une fonction universelle, rien de plus qu'une fonction
mathématique qui effectue des opérations élément par élément à
grande vitesse. Lorsque vous effectuez des opérations
mathématiques simples sur un tableau, l'ufunc est automatiquement
appelée, car les tableaux sont des enveloppes d'ufuncs.
Par exemple, lorsque vous utilisez l'opérateur + pour ajouter des
tableaux NumPy, une ufunc appelée add() est appelée
automatiquement sous le capot et fait ce qu'elle a à faire
tranquillement. Voici à quoi ressemblerait une liste Python :
 a = [1,2,3,4,5]
b = [6,7,8,9,10]
%timeit a+b
Bien qu'il s'agisse de la même opération qu'un tableau NumPy :
a = np.arange(1,6)
b = np.arange(6,11)
%timeit a+b
Comme vous pouvez le constater, l'addition d'un tableau en utilisant
les ufuncs prend beaucoup moins de temps.
Faire des maths avec les tableaux NumPy
Les opérations mathématiques sont courantes en Python, jamais
plus que dans les tableaux NumPy, et voici quelques-unes des plus
utiles que vous effectuerez :
Arithmétique de base
Ceux qui ont une expérience de Python connaissent bien les
opérations arithmétiques et savent à quel point elles sont faciles à
réaliser. Elles sont tout aussi faciles à effectuer sur les tableaux
NumPy. Tout ce qu'il faut retenir, c'est que les symboles d'opération
jouent le rôle de wrappers ufuncs :
print('Soustraire :',a-5)
print('Multiplier :',a*5)
print('Divide :',a/5)
print('Puissance :',a**2)
print('Reste :',a%5)
Soustraire : [-4 -3 -2 -1 0]
Multiplier : [ 5 10 15 20 25]
 Diviser : [0.2 0.4 0.6 0.8 1. ]
Puissance : [ 1 4 9 16 25]
Reste : [1 2 3 4 0]
Moyenne, médiane et écart-type
La recherche de la moyenne, de la médiane et de l'écart-type dans
les tableaux NumPy nécessite l'utilisation de trois méthodes -
mean(), median() et std() :
a = np.arange(5,15,2)
print('Moyenne :',np.mean(a))
print('Standard deviation :',np.std(a))
print('Median :',np.median(a))
Moyenne : 9,0
Écart-type : 2.8284271247461903
Médiane : 9,0
Valeurs min-max et leurs indices
Dans un ndarray, nous pouvons utiliser les méthodes min() et max()
pour trouver les valeurs min et max :
a = np.array([[1,6],
[4,3]])
# minimum le long d'une colonne
print('Min :',np.min(a,axis=0))
# maximum le long d'une ligne
print('Max :',np.max(a,axis=1))
Min : [1 3]
 Max : [6 4]
Vous pouvez également utiliser les méthodes argmin() et argmax()
pour obtenir les index des valeurs minimales ou maximales le long
d'un axe spécifié :
a = np.array([[1,6,5],
[4,3,7]])
# minimum le long d'une colonne
print('Min :',np.argmin(a,axis=0))
# maximum le long d'une ligne
print('Max :',np.argmax(a,axis=1))
Min : [0 1 0]
Max : [1 2]
Si l'on décompose le résultat, la valeur minimale de la première
colonne est le premier élément de la colonne. La valeur minimale de
la deuxième colonne est le deuxième élément, tandis que c'est le
premier élément de la troisième colonne.
De même, les sorties peuvent être déterminées pour les valeurs
maximales.
L'opération de tri
Tout bon programmeur vous dira que la chose la plus importante à
prendre en compte est la complexité temporelle d'un algorithme.
Une opération basique mais importante que vous êtes susceptible
d'utiliser quotidiennement en tant que scientifique des données est
le tri. C'est pourquoi un bon algorithme de tri doit être utilisé, et il
doit avoir une complexité temporelle minimale.
La bibliothèque NumPy est la plus performante lorsqu'il s'agit de trier
les éléments d'un tableau, avec une gamme décente de fonctions de
tri. Lorsque vous utilisez la méthode sort(), vous pouvez également
utiliser les fonctions mergesort, heapsort et timesort, toutes
disponibles dans NumPy, sous le capot.
a = np.array([1,4,2,5,3,6,8,7,9])
np.sort(a, kind='quicksort')
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Il est également possible de trier les tableaux sur n'importe quel axe
:
a = np.array([[5,6,7,4],
[9,2,3,7]])# trier le long de la colonne
print('Sort along column :','\n',np.sort(a,
kind='mergresort',axis=1))
# trier le long de la ligne
print('Sort along row :','\n',np.sort(a,
kind='mergresort',axis=0))
Tri par colonne :
[[4 5 6 7]
[2 3 7 9]]
Trier par ligne :
[[5 2 3 4]
[9 6 7 7]]
Tableaux NumPy et images
Les tableaux NumPy sont largement utilisés pour stocker et
manipuler des données d'image, mais qu'est-ce qu'une donnée
d'image ?
Chaque image est composée de pixels, qui sont stockés dans des
tableaux. Chaque pixel a une valeur comprise entre 0 et 255, 0 étant
un pixel noir et 255 un pixel blanc. Les images en couleur
comprennent trois tableaux bidimensionnels pour les trois canaux de
couleur (RVB - rouge, vert, bleu). Ces tableaux sont placés dos à dos
et forment un tableau tridimensionnel. Chacune des valeurs du
tableau correspond à une valeur de pixel, de sorte que la taille du
tableau dépend du nombre de pixels dans chaque dimension.
Python utilise la méthode scipy.misc.imread() de la bibliothèque
SciPy pour lire les images sous forme de tableaux. La sortie est un
tableau tridimensionnel composé des valeurs des pixels :
import numpy as np
import matplotlib.pyplot as plt
from scipy import misc

# lire l'image
im = misc.imread('./original.jpg')
# image
im
array([[[115, 106, 67],
[113, 104, 65],
[112, 103, 64],
...,
[160, 138, 37],
[160, 138, 37],
[160, 138, 37]],

[[117, 108, 69],

[115, 106, 67],
 [114, 105, 66],
...,
[157, 135, 36],
[157, 135, 34],
[158, 136, 37]],

[[120, 110, 74],

[118, 108, 72],
[117, 107, 71],
...,
La vérification du type et de la forme du tableau s'effectue de la
manière suivante :
print(im.shape)
print(type(type))
(561, 997, 3)
numpy.ndarray
Les images n'étant rien d'autre que des tableaux, nous pouvons
utiliser des fonctions de tableau pour les manipuler. Par exemple,
l'image peut être retournée horizontalement à l'aide d'une méthode
appelée np.flip() :
# flip
plt.imshow(np.flip(im, axis=1))
Il est également possible de modifier ou de normaliser la plage de
valeurs des pixels, en particulier si vous avez besoin d'un calcul plus
rapide :
im/255
array([[[0.45098039, 0.41568627, 0.2627451 ],
[0.44313725, 0.40784314, 0.25490196],
[0.43921569, 0.40392157, 0.25098039],
...,
[0.62745098, 0.54117647, 0.14509804],
[0.62745098, 0.54117647, 0.14509804],
[0.62745098, 0.54117647, 0.14509804]],

[[0.45882353, 0.42352941, 0.27058824],

[0.45098039, 0.41568627, 0.2627451 ],
[0.44705882, 0.41176471, 0.25882353],
...,
[0.61568627, 0.52941176, 0.14117647],
[0.61568627, 0.52941176, 0.13333333],
[0.61960784, 0.53333333, 0.14509804]],

[[0.47058824, 0.43137255, 0.29019608],

[0.4627451 , 0.42352941, 0.28235294],
[0.45882353, 0.41960784, 0.27843137],
...,
[0.6 , 0.52156863, 0.14117647],
[0.6 , 0.52156863, 0.13333333],
[0.6 , 0.52156863, 0.14117647]],

...,
C'est la meilleure introduction que je puisse vous donner à NumPy,
en vous montrant les méthodes et opérations de base que vous êtes
susceptible d'utiliser en tant que scientifique des données. Ensuite,
nous découvrirons comment manipuler les données à l'aide de
Pandas.
Troisième partie - Manipulation de données avec
Pandas
Pandas est un autre paquetage Python incroyablement populaire
dans le domaine de la data science, et il y a une bonne raison à cela.
Il offre aux utilisateurs des structures de données flexibles,
expressives et puissantes qui simplifient considérablement l'analyse
et la manipulation des données. L'une de ces structures est le
DataFrame.
Dans cette partie, nous allons nous intéresser aux DataFrames
Pandas, en passant par les manipulations fondamentales, jusqu'aux
opérations les plus avancées. Pour ce faire, nous répondrons aux 11
questions les plus fréquemment posées afin de vous fournir les
réponses dont vous avez besoin.
Qu'est-ce qu'un DataFrame ?
Tout d'abord, voyons ce qu'est un DataFrame.
Si vous avez l'habitude d'utiliser le langage R, vous savez déjà qu'un
cadre de données fournit des grilles rectangulaires pour stocker des
données afin de pouvoir les consulter facilement. Les lignes des
grilles correspondent toutes à une mesure ou à une valeur
d'instance, et les colonnes sont des vecteurs contenant des données
relatives à une variable spécifique. Il n'est donc pas nécessaire que
les lignes contiennent des types de valeurs identiques, bien qu'elles
puissent le faire si nécessaire. Elles peuvent stocker n'importe quel
type de valeur, comme des valeurs logiques, des caractères, des
valeurs numériques, etc.
Les DataFrames de Python sont très similaires. Elles sont incluses
dans la bibliothèque Pandas et sont définies comme des structures
de données bidimensionnelles, étiquetées et dont les colonnes
peuvent contenir différents types.
On peut dire que les DataFrames Pandas comportent trois éléments
principaux : les données, l'index et les colonnes.
Tout d'abord, nous pouvons stocker le type de données suivant dans
un DataFrame :
 Un DataFrame Pandas
Une série Pandas, un tableau unidimensionnel étiqueté
qui peut contenir n'importe quel type de données avec
un index ou une étiquette d'axe. Un exemple simple
serait une colonne DataFrame
Un tableau numérique NumPy, qui peut être une
structure ou un enregistrement.
Un tableau bidimensionnel
Un dictionnaire contenant des listes, des séries, des
dictionnaires ou des ndarrays unidimensionnels
NOTE
Ne confondez pas np.ndarray avec np.array(). Le premier est un
type de données, et le second est une fonction qui utilise d'autres
structures de données pour créer des tableaux.
Avec un tableau structuré, un utilisateur peut manipuler des données
via des champs, chacun nommé différemment. L'exemple ci-dessous
montre la création d'un tableau structuré contenant trois tuples. Le
premier élément de chaque tuples est appelé foo et est de type int.
Le deuxième élément est un flottant appelé bar.
Le même exemple montre un tableau d'enregistrements. Ceux-ci
sont utilisés pour étendre les propriétés d'un tableau structuré, et les
utilisateurs peuvent accéder aux champs par attribut et non par
index. Comme vous pouvez le voir dans l'exemple, nous accédons
aux valeurs de foo dans le tableau d'enregistrements appelé r2 :
# Un tableau structuré
my_array = np.ones(3, dtype=([('foo', int), ('bar', float
)]))
# Imprimer le tableau structuré
_____(my_array['foo'])
 # Un tableau d'enregistrements
my_array2 = my_array.view(np.recarray)
# Imprimer le tableau des enregistrements
_____(mon_tableau2.foo)
Deuxièmement, les noms d'index et de colonne peuvent également
être spécifiés pour le DataFrame. L'index fournit les différences entre
les lignes, tandis que le nom de la colonne indique les différences
entre les colonnes. Vous verrez plus loin qu'il s'agit de composants
DataFrame pratiques pour la manipulation des données.
Si vous n'avez pas encore Pandas ou NumPy sur votre système, vous
pouvez les importer avec la commande import suivante :
import numpy as np
import pandas as pd
Maintenant que vous savez ce que sont les DataFrames et à quoi
elles peuvent servir, nous allons tout savoir sur elles en répondant à
ces 11 questions.
Première question : Comment créer un DataFrame
Pandas ?
La première étape du regroupement ou de la manipulation de
données consiste à créer votre DataFrame, et vous pouvez le faire
de deux manières : convertir une structure existante ou en créer une
nouvelle. Dans cette partie, nous ne nous intéresserons qu'à la
conversion de structures existantes, mais nous aborderons la
création de nouvelles structures un peu plus loin.
Les ndarrays NumPy ne sont qu'un des éléments que vous pouvez
utiliser comme entrée d'un DataFrame. Créer un DataFrame à partir
d'un tableau NumPy est assez simple. Tout ce que vous avez à faire
est de passer le tableau à la fonction DataFrame() dans l'argument
data :
 data = np.array(['','Col1','Col2'],
['Row1',1,2],
['Rangée2',3,4]])

print(pd.DataFrame(data=data[1 :,1 :],

index=données[1 :,0],
columns=data[0,1 :]))
Une chose à laquelle vous devez prêter attention est la manière dont
le DataFrame est construit à partir des éléments du tableau NumPy.
Tout d'abord, les valeurs des listes commençant par Row1 et Row2
sont sélectionnées. Ensuite, les numéros de ligne ou l'index, Row1
ou Row2, sont sélectionnés, suivis des noms de colonnes Col1 et
Col2.
Ensuite, nous imprimons une petite sélection de données. Comme
vous pouvez le voir, c'est à peu près la même chose que lorsque
vous sous-ensemblez un tableau NumPy à deux dimensions - la ligne
est indiquée en premier, là où vous voulez que vos données soient
recherchées, suivie de la colonne. N'oubliez pas qu'en Python, les
indices commencent à 0. Dans l'exemple ci-dessus, nous cherchons
dans les lignes de l'indice 1 jusqu'à la fin et choisissons tous les
éléments après l'indice 1. Le résultat est que les éléments 1, 2, 3 et
4 sont sélectionnés.
Il s'agit de la même approche pour créer un DataFrame que pour
toute structure prise en entrée par DataFrame().
Essayez-le vous-même dans l'exemple suivant :
# Prendre un tableau 2D comme entrée de votre DataFrame
my_2darray = np.array([[1, 2, 3], [4, 5, 6]])
print(________________)
# Prendre un dictionnaire comme entrée de votre DataFrame
 my_dict = {1 : ['1', '3'], 2 : ['1', '2'], 3 : ['2', '4']}.
print(________________)
# Prendre un DataFrame comme entrée de votre DataFrame
my_df = pd.DataFrame(data=[4,5,6,7], index=range(0,4),
columns=['A'])
print(________________)
# Prendre une série en entrée de votre DataFrame
my_series = pd.Series({"Belgium" : "Brussels", "India" :
"New
Delhi", "Royaume-Uni" : "Londres", "États-Unis"
: "Washington"})
print(________________)
L'index de votre série et de votre DataFrame contient les clés du
dictionnaire d'origine, mais triées : l'index 0 correspond à la
Belgique, tandis que l'index 3 correspond aux États-Unis. Une fois
votre DataFrame créé, vous pouvez en savoir plus sur lui. Par
exemple, la fonction len() ou la propriété shape peuvent être
utilisées avec la propriété .index :
df = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6]]))
# Utiliser la propriété `shape` (forme)
print(________)
# Ou utiliser la fonction `len()` avec la propriété `index`.
print(____________)
Ces options fournissent différentes informations sur le DataFrame.
Nous obtenons les dimensions du DataFrame en utilisant la propriété
shape, c'est-à-dire la hauteur et la largeur du DataFrame. Et si vous
utilisez la propriété index et la fonction len() ensemble, vous
n'obtiendrez que la hauteur du DataFrame.
La fonction df[0].count() pourrait également être utilisée pour
obtenir plus d'informations sur la hauteur du DataFrame mais, s'il y a
des valeurs NaN, elle ne les fournira pas, c'est pourquoi .count()
n'est pas toujours la meilleure option.
Maintenant que nous savons comment créer un DataFrame à partir
d'une structure existante, il est temps de passer aux choses
sérieuses et d'examiner certaines des opérations de base.
Question 2 - Comment sélectionner une colonne ou
un index dans un DataFrame ?
Avant de commencer les opérations de base, telles que la
suppression, l'ajout ou le renommage, nous devons apprendre à
sélectionner les éléments. Il n'est pas difficile de sélectionner une
valeur, une colonne ou un index dans un DataFrame. En fait, c'est à
peu près la même chose que dans d'autres langages d'analyse de
données. Voici un exemple des valeurs contenues dans le DataFrame
:
ABC
0123
1456
2789
Nous voulons accéder à la valeur de la colonne A à l'index 0 et nous
avons plusieurs options pour le faire :
# Utilisation de `iloc[]`
print(df.iloc[0][0])
# Utilisation de `loc[]`
print(df.loc[0]['A'])
 # Utilisation de `at[]`
print(df.at[0,'A'])
# Utilisation de `iat[]`
print(df.iat[0,0])
Vous devez vous souvenir de deux d'entre eux : .iloc[] et .loc[]. Il
existe quelques différences entre eux, mais nous les aborderons
dans un instant.
Voyons maintenant comment sélectionner des valeurs. Si vous
vouliez des lignes et des colonnes, vous feriez ceci :
# Utiliser `iloc[]` pour sélectionner la ligne `0`.
print(df.iloc[_])
# Utiliser `loc[]` pour sélectionner la colonne `'A'`
print(df.loc[ :,'_'])
Pour l'instant, il vous suffit de savoir que l'on peut accéder aux
valeurs en utilisant le nom de leur étiquette, leur index ou la position
de leur colonne.
Question 3 : Comment ajouter une ligne, une colonne
ou un index à un DataFrame ?
Maintenant que vous savez comment sélectionner des valeurs, il est
temps de comprendre comment une ligne, une colonne ou un index
est ajouté.
Ajout d'un index
Lorsqu'un DataFrame est créé, vous voulez vous assurer que vous
obtenez le bon index et vous pouvez donc ajouter des données à
l'argument index. Si celui-ci n'est pas spécifié, l'index du DataFrame
aura par défaut une valeur numérique et commencera par 0, jusqu'à
la dernière ligne du DataFrame.
Cependant, même si votre index est automatiquement spécifié, vous
pouvez toujours réutiliser une colonne, en la transformant en votre
index. Pour ce faire, nous appelons set_index() sur le DataFrame :
# Imprimez votre DataFrame `df` pour le vérifier
print(__)
# Définissez 'C' comme l'index de votre DataFrame
df.______('C')
Ajout d'une ligne
Avant d'en arriver à la solution, nous devons d'abord examiner le
concept de loc et sa différence avec .iloc, .ix et d'autres attributs
d'indexation :

.loc[] - travaille sur vos étiquettes d'index. Par exemple,

si vous avez loc[2], vous recherchez les valeurs du
DataFrame dont l'index est 2.
.iloc[] - fonctionne sur vos positions d'index. Par
exemple, si vous avez iloc[2], vous recherchez les valeurs
du DataFrame avec un index étiqueté 2.
.ix[] - C'est un peu plus complexe. Si vous disposez d'un
index basé sur un nombre entier, une étiquette est
transmise à .ix[], ce qui signifie que vous recherchez les
valeurs du DataFrame dont l'index porte le numéro 2.
Dans ce cas, .ix[2] signifie que vous recherchez les
valeurs du DataFrame dont l'index porte l'étiquette 2.
Cela est similaire à .loc[] mais, lorsque vous n'avez pas
d'index purement basé sur des nombres entiers, .ix
fonctionne également avec des positions.
Simplifions un peu les choses à l'aide d'un exemple :
df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7
, 8, 9]]), index=[2, 'A', 4], columns=[48, 49, 50])
 # Passez `2` à `loc`
print(df.loc[_])
# Passez `2` à `iloc`
print(df.iloc[_])
# Passez `2` à `ix`
print(df.ix[_])
Notez que nous avons utilisé un DataFrame qui n'est pas basé
uniquement sur des entiers, juste pour vous montrer les différences
entre eux. Comme vous pouvez le constater, vous n'obtenez pas le
même résultat lorsque vous passez 2 à .loc[] ou .iloc[]/.ix[].
.loc[] examinera les valeurs étiquetées 2, et vous obtiendrez peut-
être quelque chose comme ce qui suit :
48 1
49 2
50 3
.iloc[] regarde la position de l'index, et en passant 2, vous
obtiendrez quelque chose comme ceci :
48 7
49 8
50 9
Parce que nous n'avons pas que des entiers dans l'index, .ix[] se
comporte de la même manière que .iloc[] et examine les positions
de l'index. Dans ce cas, vous obtenez les mêmes résultats que
.iloc[].
Il est essentiel de comprendre la différence entre ces trois éléments
pour ajouter des lignes à un DataFrame. Vous devriez également
avoir compris qu'il est recommandé d'utiliser .loc[] lorsque vous
insérez des lignes. Si vous utilisez df.ix[], vous risquez de faire
référence à des valeurs indexées numériquement et d'écraser une
ligne existante du DataFrame, même si c'est de manière
accidentelle.
Une fois de plus, regardez l'exemple ci-dessous".
df = pd._________(data=np.array([[1, 2, 3], [4, 5, 6], [7
, 8, 9]]), index= [2.5, 12.6, 4.8], columns=[48, 49, 50])
# Il n'y a pas d'index étiqueté `2`, donc vous allez changer
le fichier
index à la position `2`
df.ix[2] = [60, 50, 40]
print(df)
# Ceci créera un index étiqueté `2` et ajoutera le nouveau
fichier
valeurs
df.loc[2] = [11, 12, 13]
print(df)
Il est facile de comprendre comment tout cela peut prêter à
confusion.
Ajouter une colonne
Parfois, vous pouvez souhaiter que votre index fasse partie d'un
DataFrame, ce qui peut être fait en assignant une colonne
DataFrame ou en référençant et en assignant une colonne que vous
n'avez pas encore créée. Cela se fait de la manière suivante :
df = pd._________(data=np.array([[1, 2, 3], [4, 5, 6], [7,
8, 9]]), columns=['A', 'B', 'C'])
# Utiliser `.index`
 df['D'] = df.index
# Imprimer `df`
print(__)
Ce que vous faites ici, c'est indiquer au DataFrame que l'index doit
être la colonne A.
Cependant, l'ajout de colonnes peut se faire de la même manière
que l'ajout d'un index - .loc[] ou .iloc[] est utilisé mais, cette fois,
une série est ajoutée au DataFrame à l'aide de .loc[] :
# Étudier le DataFrame `df`
print(__)
# Ajouter une colonne à `df`
df.loc[ :, 4] = pd.Series(['5', '6'], index=df.index)
# Imprimer à nouveau `df` pour voir les changements
_____(__)
N'oubliez pas qu'un objet Series est similaire à une colonne d'un
DataFrame, ce qui explique pourquoi il est facile de les ajouter à des
DataFrames existantes. Notez également que l'observation
précédente concernant .loc[] reste valable, même lors de l'ajout de
colonnes.
Réinitialisation de l'index
Si votre index n'est pas tout à fait comme vous le souhaitez, vous
pouvez le réinitialiser en utilisant reset_index(). Cependant, faites
attention à ce que vous faites, car il est possible de passer des
arguments qui peuvent casser votre réinitialisation.
# Vérifier l'index étrange de votre DataFrame
print(df)
# Utilisez `reset_index()` pour réinitialiser les valeurs.
 df_reset = df.__________(level=0, drop=True)
# Imprimer `df_reset`
print(df_reset)
Utilisez le code ci-dessus mais remplacez drop par inplace et voyez
ce qui se passe.
L'argument drop est utile pour indiquer que vous voulez que l'index
existant soit éliminé, mais si vous utilisez inplace, l'index original
sera ajouté, avec des flottants, en tant que colonne supplémentaire.
Question 4 : Comment supprimer des indices, des
lignes ou des colonnes d'un cadre de données ?
Maintenant que vous savez comment ajouter des lignes, des
colonnes et des indices, voyons comment les supprimer de la
structure de données.
Suppression d'un index
Supprimer l'index d'un DataFrame n'est pas toujours une bonne
idée, car les séries et les DataFrames doivent toujours en avoir un.
Cependant, vous pouvez essayer ceci à la place :

Réinitialisez l'index de votre DataFrame, comme nous

l'avons fait précédemment
Si votre index a un nom, utilisez del df.index.name pour
le supprimer.
Supprimez les valeurs en double - pour ce faire,
réinitialisez l'index, supprimez les doublons de la colonne
d'index et rétablissez la colonne sans doublons comme
index :
df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8,
9], [40, 50, 60], [23, 35, 37]]),
index= [2.5, 12.6, 4.8, 4.8, 2.5],
 columns=[48, 49, 50])

df.___________.drop_duplicates(subset='index',
keep='last').set_index('index')

Enfin, vous pouvez supprimer un index avec une ligne -

nous y reviendrons plus tard.
Suppression d'une colonne
Pour supprimer une ou plusieurs colonnes, on utilise la méthode
drop() :
# Vérifier le DataFrame `df`
print(__)
# Supprimez la colonne portant l'étiquette "A".
df.____('A', axis=1, inplace=True)
# Déposer la colonne à la position 1
df.____(df.columns[[1]], axis=1)
Cela peut sembler trop simple, et c'est parce que la méthode drop()
a quelques arguments supplémentaires :

Lorsque l'argument de l'axe indique des lignes, il vaut 0,

et lorsqu'il indique des colonnes, il vaut 1.
Inplace peut être défini sur true, ce qui permet de
supprimer la colonne sans qu'il soit nécessaire de
réaffecter le DataFrame.
Suppression d'une ligne
Vous pouvez utiliser df.drop_duplicates() pour supprimer les lignes
en double, mais vous pouvez aussi le faire en ne considérant que les
valeurs de la colonne :
# Vérifiez votre DataFrame `df`
 print(__)
# Supprimer les doublons dans `df`
df.________([48], keep='last')
Si vous n'avez pas besoin d'ajouter de critères uniques à votre
suppression, la méthode drop() est idéale, en utilisant la propriété
index pour spécifier l'index de la ligne à supprimer :
# Vérifier le DataFrame `df`
print(__)
# Déposer l'index à la position 1
df.____(df.index[_])
Vous pouvez ensuite réinitialiser votre index.
Question cinq : Comment renommer les colonnes ou
l'index d'un DataFrame ?
Si vous souhaitez modifier les valeurs des index ou des colonnes de
votre DataFrame, vous devez utiliser une méthode appelée
.rename() :
# Vérifiez votre DataFrame `df`
print(__)
# Définissez les nouveaux noms de vos colonnes
newcols = {
A" : "new_column_1",
B" : "new_column_2",
C" : "new_column_3".
}
# Utilisez `rename()` pour renommer vos colonnes
 df.______(columns=newcols, inplace=True)
# Utilisez `rename()` pour votre index
df.______(index={1 : 'a'})
Si vous changiez la valeur de l'argument inplace en False, vous
verriez que le DataFrame n'a pas été réaffecté lorsque les colonnes
ont été renommées. Ainsi, la deuxième partie de l'exemple prendrait
en entrée l'argument original plutôt que celui renvoyé par l'opération
rename() dans la première partie.
Question six : Comment formater les données du
DataFrame ?
Il peut arriver que vous souhaitiez effectuer des opérations sur les
valeurs des DataFrames. Nous allons examiner quelques-unes des
méthodes les plus importantes pour formater les valeurs des
DataFrame.
Remplacer toutes les occurrences de chaînes de
caractères
La méthode replace() peut facilement être utilisée lorsque vous
souhaitez remplacer des chaînes de caractères spécifiques dans le
DataFrame. Tout ce que vous avez à faire est de passer les valeurs
que vous voulez modifier et les nouvelles valeurs de remplacement,
comme ceci :
# Etudie d'abord le DataFrame `df`.
_____(df)
# Remplacer les chaînes par des valeurs numériques (0-4)
df._______(['Affreux', 'Médiocre', 'OK', 'Acceptable',
'Parfait'], [0, 1, 2, 3, 4])
Vous pouvez également utiliser l'argument regex pour vous aider
avec des combinaisons bizarres de chaînes de caractères :
 # Vérifiez votre DataFrame `df`
print(df)
# Remplacer les chaînes par d'autres avec `regex`
df.replace({'\n' : '<br>'}, regex=True)
En termes simples, replace() est la meilleure méthode pour
remplacer des chaînes ou des valeurs dans le DataFrame.
Suppression des bits des chaînes de caractères dans les
cellules d'un DataFrame
Il n'est pas facile d'enlever les bouts de ficelles et la tâche peut
s'avérer quelque peu fastidieuse. Il existe cependant une solution
relativement simple :
# Vérifiez votre DataFrame
_____(df)
# Supprimer les parties non désirées des chaînes de
caractères dans le `résultat`
colonne
df['result'] = df['result'].map(lambda x : x.lstrip('+-'
).rstrip('aAbBcC'))
# Vérifier à nouveau le résultat
df
Pour appliquer la fonction lambda élément par élément ou sur des
éléments individuels de la colonne, nous utilisons map() sur le
résultat de la colonne. La fonction map() prend la valeur de la chaîne
et supprime le + ou le - à gauche et un ou plusieurs des aABbcC que
vous voyez à droite.
Diviser le texte d'une colonne en plusieurs lignes
C'est un peu plus difficile, mais l'exemple ci-dessous vous explique
ce qu'il faut faire :
# Inspecter votre DataFrame `df`
print(__)
# Séparer les deux valeurs de la troisième ligne
# En faire une série
# Empiler les valeurs
ticket_series = df['Ticket'].str.split(' ').apply(pd
.Series, 1).stack()
# Se débarrasser de la pile :
# Abaisser le niveau pour l'aligner sur le DataFrame
ticket_series.index = ticket_series.index.droplevel(-1)
# Faites de votre `série_de_tickets` un cadre de données
(dataframe)
ticketdf = pd.________(ticket_series)
# Supprimez la colonne `Ticket` de votre DataFrame
del df['Ticket']
# Joindre le DataFrame `ticketdf` à `df`
df.____(ticketdef)
# Vérifier le nouveau `df`
df
Ce que vous faites, c'est.. :

Inspection du DataFrame. Les valeurs de la dernière

colonne et de la dernière ligne sont longues. Il semble
 que nous ayons deux billets parce qu'un invité a emmené
son partenaire au concert.
La colonne Ticket est supprimée du DataFrame df et les
chaînes de caractères sont placées sur un espace. Cela
permet de s'assurer que les deux tickets se trouvent
dans des lignes distinctes. Ces quatre valeurs, qui sont
les numéros de ticket, sont placées dans un objet Series
:
01
0 23:44:55 NaN
1 66:77:88 NaN
2 43:68:05 56:34:12

Quelque chose ne va toujours pas car nous pouvons voir

des valeurs NaN. Les séries doivent être empilées pour
éviter les valeurs NaN dans le résultat.
Ensuite, nous voyons les séries empilées :
0 0 23:44:55
1 0 66:77:88
2 0 43:68:05
1 56:34:12

Cela ne fonctionne pas vraiment non plus, et c'est

pourquoi le niveau est abaissé, de sorte qu'il s'aligne sur
le DataFrame :
0 23:44:55
1 66:77:88
2 43:68:05
2 56:34:12
 dtype : objet

C'est ce que vous voulez vraiment voir.

Ensuite, votre série est transformée en DataFrame afin
qu'elle puisse être jointe au DataFrame initial.
Cependant, comme nous ne voulons pas de doublons, la
colonne Ticket d'origine doit être supprimée.
Application de fonctions à des lignes ou à des colonnes
Vous pouvez appliquer des fonctions aux données du DataFrame
pour les modifier. Tout d'abord, nous créons une fonction lambda :
doubleur = lambda x : x*2
Ensuite, nous appliquons la fonction :
# Étudier le DataFrame `df`.
_____(__)
# Appliquer la fonction `doubler` à la colonne `A` du
DataFrame
df['A'].apply(doubler)
Notez que la ligne DataFrame peut également être sélectionnée et
que la fonction lambda doubleur peut lui être appliquée. Vous savez
comment sélectionner des lignes - en utilisant .loc[] ou .iloc[].
Ensuite, quelque chose comme ce qui suit sera exécuté, selon que
votre index est sélectionné sur la base de la position ou de
l'étiquette :
df.loc[0].apply(doubler)
Ici, la fonction apply() ne concerne que la fonction doubleur sur l'axe
DataFrame. Cela signifie que vous ciblez les colonnes ou l'index -
une ligne ou une colonne en termes simples.
Toutefois, si vous souhaitez que le doublage soit appliqué par
élément, vous pouvez utiliser la fonction map(). Remplacez
simplement apply() par map(), et n'oubliez pas que le doubleur doit
toujours être passé à map() pour s'assurer que les valeurs sont
multipliées par 2.
Supposons que cette fonction de doublement doive être appliquée à
l'ensemble du DataFrame, et pas seulement à la colonne A. Dans ce
cas, la fonction de doublement est appliquée à l'aide de applymap()
à chaque élément de votre DataFrame :
doubled_df = df.applymap(doubler)
print(doubled_df)
Ici, nous avons travaillé avec des fonctions anonymes créées à
l'exécution ou des fonctions lambda, mais vous pouvez créer les
vôtres :
def doubler(x) :
si x % 2 == 0 :
Retourner x
d'autre part :
retour x * 2
# Utilisez `applymap()` pour appliquer `doubler()` à votre
DataFrame
doubled_df = df.applymap(doubler)
# Vérifier le cadre de données
print(doubled_df)
Question sept : Comment créer un DataFrame vide ?
Nous utiliserons pour cela la fonction DataFrame(), en transmettant
les données que nous voulons inclure, ainsi que les colonnes et les
indices. N'oubliez pas que vous n'êtes pas obligé d'utiliser des
données homogènes pour cela - elles peuvent être de n'importe quel
type.
Il existe plusieurs façons d'utiliser la fonction DataFrame() pour créer
des DataFrames vides. Tout d'abord, numpy.nan peut être utilisé
pour l'initialiser avec des NaN. La fonction numpy.nan a un type de
données float :
df = pd.DataFrame(np.nan, index=[0,1,2,3], columns=['A'])
print(df)
Pour l'instant, le type de données de ce DataFrame est déduit. C'est
le type par défaut et, comme numpy.nan possède le type de
données float, c'est le type de valeurs que le DataFrame contiendra.
Cependant, le DataFrame peut également être forcé à être d'un type
spécifique en utilisant l'attribut dtype et en fournissant le type que
vous voulez, comme ceci :
df = pd.DataFrame(index=range(0,4),columns=['A'], dtype
='float')
print(df)
Si les étiquettes de l'index ou de l'axe ne sont pas spécifiées, les
données d'entrée sont utilisées pour les construire, en utilisant des
règles de bon sens.
Question huit : Lorsque j'importerai des données,
Pandas reconnaîtra-t-il les dates ?
Oui, Pandas peut reconnaître les dates, mais seulement avec un peu
d'aide. Lorsque vous lisez les données, par exemple à partir d'un
fichier CSV, l'argument parse_dates doit être ajouté :
import pandas as pd
pd.read_csv('yourFile', parse_dates=True)

# ou cette option :
 pd.read_csv('yourFile', parse_dates=['columnName'])
Cependant, il est toujours possible que vous rencontriez des formats
de date et d'heure bizarres. Il n'y a pas lieu de s'inquiéter, car il est
assez simple de construire un analyseur syntaxique pour gérer cela.
Par exemple, vous pouvez créer une fonction lambda pour prendre la
date et l'heure et utiliser une chaîne de format pour la contrôler :
import pandas as pd
dateparser = lambda x : pd.datetime.strptime(x, '%Y-%m-
%d %H:%M:%S')

# Ce qui donne votre commande de lecture :

pd.read_csv(infile, parse_dates=['columnName'],
date_parser=dateparse)

# Ou combiner deux colonnes en une seule colonne

DateTime
pd.read_csv(infile, parse_dates={'datetime' : ['date',
'time']}, date_parser=dateparse)
Question neuf : Quand un DataFrame doit-il être
remodelé ? Pourquoi et comment ?
Lorsque vous remodelez un DataFrame, vous le transformez pour
que la structure obtenue corresponde mieux à votre analyse de
données. Nous pouvons en déduire que le remodelage concerne
moins le formatage des valeurs du DataFrame que la transformation
de la forme du DataFrame.
Cela vous indique donc quand et pourquoi vous devez remodeler
votre peau, mais comment le faire ?
Vous avez le choix entre trois possibilités, que nous allons examiner
tour à tour :
Pivot
La fonction pivot() est utilisée pour créer un tableau dérivé à partir
du tableau original. Trois arguments peuvent être transmis à la
fonction :

values - vous permet de spécifier les valeurs du

DataFrame d'origine à intégrer dans votre tableau croisé
dynamique.
columns - ce à quoi cet argument est passé devient une
colonne du tableau.
index - tout ce à quoi cet argument est transmis devient
un index.
# Importation de pandas
import ______ sous le nom de pd
products = pd.DataFrame({'category' : ['Cleaning',
Nettoyage", "Divertissement", "Divertissement", "Tech",
Tech],
magasin" : ["Walmart", "Dia",
Walmart", "Fnac", "Dia", "Walmart"],
prix" : [11,42, 23,50, 19,99, 15
.95, 55.75, 111.55],
'testscore' : [4, 3, 5, 7, 5, 8]})
# Utiliser `pivot()` pour pivoter le DataFrame
pivot_products = products._____(index='category', columns
='store', values='price')
# Vérifier le résultat
 print(produits_pivot)
Si vous ne spécifiez pas les valeurs que vous voulez dans le tableau,
vous finirez par pivoter sur plusieurs colonnes :
# Importer la bibliothèque Pandas
import ______ sous le nom de pd
# Construire le DataFrame
products = pd.DataFrame({'category' : ['Cleaning',
Nettoyage", "Divertissement", "Divertissement", "Tech",
Tech],
magasin" : ["Walmart", "Dia",
Walmart", "Fnac", "Dia", "Walmart"],
prix" : [11,42, 23,50, 19,99, 15
.95, 55.75, 111.55],
'testscore' : [4, 3, 5, 7, 5, 8]})
# Utilisez `pivot()` pour pivoter votre DataFrame
pivot_products = products._____(index='category', columns
='store')
# Vérifier les résultats
print(produits_pivot)
Les données ne doivent pas comporter de lignes contenant des
valeurs en double pour les colonnes spécifiées. Si c'est le cas, un
message d'erreur est généré. Si vos données ne peuvent pas être
uniques, vous devez utiliser une autre méthode, pivot_table() :
# Importer la bibliothèque Pandas
import ______ sous le nom de pd
 # Votre cadre de données
products = pd.DataFrame({'category' : ['Cleaning',
Nettoyage", "Divertissement", "Divertissement", "Tech",
Tech],
magasin" : ["Walmart", "Dia",
Walmart", "Fnac", "Dia", "Walmart"],
prix" : [11,42, 23,50, 19,99, 15
.95, 19.99, 111.55],
'testscore' : [4, 3, 5, 7, 5, 8]})
# Pivoter votre DataFrame `products` avec `pivot_table()`
pivot_products = products.___________(index='category',
columns='store', values='price', aggfunc='mean')
# Vérifier les résultats
print(produits_pivot)
Nous avons passé un argument supplémentaire à la méthode
pivot_table, appelé aggfunc. Il indique que plusieurs valeurs sont
combinées à l'aide d'une fonction d'agrégation. Dans notre exemple,
nous avons utilisé la fonction mean.
Remodeler un DataFrame en utilisant Stack() et Unstack()
Si vous vous reportez à la question 5, vous verrez que nous avons
déjà utilisé un exemple d'empilement. Lorsqu'un DataFrame est
empilé, il devient plus grand. L'indice de la colonne la plus proche
est déplacé pour devenir l'indice de la ligne la plus proche, ce qui
renvoie un DataFrame avec un indice contenant un nouveau niveau
d'étiquettes de la ligne la plus proche.
Inversement, nous pouvons utiliser unstack() pour transformer
l'index de la ligne la plus proche en index de la colonne la plus
proche.
Utilisation de melt() pour remodeler un DataFrame
La fusion est utile lorsque vos données comportent au moins une
colonne qui est une variable d'identification et que toutes les autres
sont des variables mesurées.
Les variables mesurées sont considérées comme non pivotées par
rapport à l'axe des lignes. Cela signifie que lorsque les variables
mesurées étaient dispersées sur la largeur du DataFrame, melt()
s'assurera qu'elles sont placées à sa hauteur. Ainsi, au lieu de
s'élargir, le DataFrame s'allonge. Il en résulte une paire de colonnes
non identifiées appelées valeur et variable. Voici un exemple pour
vous montrer ce que cela signifie :
# Le DataFrame `people` (Personnes)
people = pd.DataFrame({'FirstName' : ['John', 'Jane'],
Nom : ['Doe', 'Austen'],
Type de sang' : ['A-', 'B+'],
'Poids' : [90, 64]})
# Utiliser `melt()` sur le DataFrame `people`.
print(pd.____(people, id_vars=['FirstName', 'LastName'],
var_name='mesures'))
Question dix : Comment faire pour itérer sur un
DataFrame ?
L'itération sur les lignes du DataFrame s'effectue à l'aide d'une
boucle for et en appelant iterrows() sur le DataFrame :
df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7,
8, 9]]), columns=['A', 'B', 'C'])
for index, row in df.iterrows() :
 print(ligne['A'], ligne['B'])
L'utilisation de iterrows() vous permet de boucler efficacement sur
les lignes sous forme de paires - index, série. En termes simples, le
résultat sera constitué de tuples (index, ligne).
Question 11 : Comment écrire un DataFrame dans un
fichier ?
Lorsque vous aurez terminé tout ce que vous voulez faire, vous
voudrez probablement exporter votre DataFrame dans un autre
format. Nous allons examiner deux façons de le faire : Excel ou un
fichier CSV.
Sortie vers un fichier CSV
L'écriture dans un fichier CSV nécessite l'utilisation de to_csv() :
import pandas as pd
df.to_csv('myDataFrame.csv')
Ce code semble simple mais, pour beaucoup de gens, c'est là que
les choses se compliquent. En effet, chacun a ses propres exigences
en ce qui concerne la sortie des données. Il se peut que vous ne
souhaitiez pas utiliser les virgules comme délimiteurs ou que vous
vouliez un type d'encodage spécifique.
Nous pouvons contourner ce problème en passant des arguments
spécifiques à to_csv() pour nous assurer que vous obtenez la sortie
dans le format que vous souhaitez :

La délimitation d'une tabulation nécessite l'argument sep

:
import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t')

L'argument encodage vous permet de choisir l'encodage

de caractères que vous souhaitez :
 import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t', encoding='utf-8')

Vous pouvez même spécifier comment représenter les

valeurs manquantes ou NaN - vous pouvez ou non
vouloir que l'en-tête soit édité, vous pouvez ou non
vouloir que les noms de ligne soient écrits, vous pouvez
vouloir une compression, et ainsi de suite. Vous pouvez
découvrir comment faire tout cela en lisant cette page.
Sortie vers un fichier Excel
Dans ce cas, vous utilisez to_excel(), mais ce n'est pas aussi simple
que pour le fichier CSV :
import pandas as pd
writer = pd.ExcelWriter('myDataFrame.xlsx')
df.to_excel(writer, 'DataFrame')
writer.save()
Cependant, il convient de noter que vous avez besoin de nombreux
arguments supplémentaires, tout comme avec to_csv, pour vous
assurer que vos données sont produites comme vous le souhaitez. Il
s'agit notamment de startrow, startcol, et d'autres encore, que vous
pouvez découvrir sur cette page.
Plus que de simples cadres de données
Bien qu'il s'agisse d'un tutoriel Pandas assez basique, il vous donne
une bonne idée de son utilisation. Les 11 questions auxquelles nous
avons répondu sont celles qui sont le plus souvent posées, et elles
représentent les compétences fondamentales dont vous avez besoin
pour importer vos données, les nettoyer et les manipuler.
Dans le prochain chapitre, nous aborderons brièvement la
visualisation de données avec Matplotlib et Seaborn.
Quatrième partie - Visualisation de données
avec Matplotlib et Seaborn
La visualisation des données est l'un des éléments les plus
importants de la communication de vos résultats aux autres. Qu'elle
prenne la forme de diagrammes circulaires, de diagrammes de
dispersion, de diagrammes en bâtons, d'histogrammes ou de toute
autre forme de visualisation, il est essentiel de bien la réaliser pour
tirer des informations utiles des données. Heureusement, la
visualisation des données est facile avec Python.
On peut dire que la visualisation des données est un élément clé des
tâches analytiques, comme l'analyse exploratoire des données, la
synthèse des données, l'analyse des résultats d'un modèle, etc.
Python offre de nombreuses bibliothèques et outils pour nous aider à
obtenir de bonnes informations à partir des données, et le plus
couramment utilisé est Matplotlib. Cette bibliothèque nous permet de
générer toutes sortes de visualisations, à partir du même code si
vous le souhaitez.
Une autre bibliothèque utile est Seaborn, construite sur Matplotlib,
qui fournit des visualisations de données très esthétiques et
sophistiquées, d'un point de vue statistique. La compréhension de
ces bibliothèques est essentielle pour que les scientifiques des
données puissent tirer le meilleur parti de leur analyse de données.
Utilisation de Matplotlib pour générer des
histogrammes
Matplotlib regorge d'outils qui permettent une visualisation rapide
des données. Par exemple, les chercheurs qui souhaitent analyser de
nouveaux ensembles de données veulent souvent voir comment les
valeurs sont réparties sur un ensemble de colonnes, et la meilleure
façon de le faire est d'utiliser un histogramme.
Un histogramme génère des approximations de distributions en
utilisant une plage définie pour sélectionner les résultats, en plaçant
chaque ensemble de valeurs dans un godet ou une case. L'utilisation
de Matplotlib facilite ce type de visualisation.
Nous utiliserons le jeu de données FIFA19, que vous pouvez
télécharger ici. Exécutez ces codes pour voir les résultats par vous-
même.
Pour commencer, si ce n'est pas déjà fait, importez Pandas :
import pandas as pd
Ensuite, le module pyplot de Matplotlib est nécessaire, et la manière
habituelle de l'importer est plt :
import matplotlib.pyplot as plt
Ensuite, les données doivent être lues dans un DataFrame. Nous
utiliserons la méthode set_option() de Pandas pour assouplir la
limite d'affichage des lignes et des colonnes :
df = pd.read_csv("fifa19.csv")

pd.set_option('display.max_columns', None)

pd.set_option('display.max_rows', None)
Nous pouvons maintenant imprimer les cinq premières lignes des
données, ce que nous faisons avec la méthode head() :
print(df.head())
Un histogramme peut être généré pour n'importe quelle colonne
numérique. La méthode hist() est appelée sur l'objet plt et la
colonne DataFrame sélectionnée est transmise. Nous allons essayer
cette méthode sur la colonne Overall car elle correspond à
l'évaluation globale des joueurs :
plt.hist(df['Overall'])
Les axes a et y peuvent également être étiquetés, ainsi que le titre
du tracé, selon trois méthodes :

xlabel()
 ylabel()
titre()
plt.xlabel('Overall')

plt.ylabel('Fréquence')

plt.title('Histogramme de l'évaluation globale')

plt.show()
Cet histogramme est l'un des meilleurs moyens de voir la distribution
des valeurs et de déterminer celles qui apparaissent le plus et le
moins.
Utilisation de Matplotlib pour générer des
diagrammes de dispersion
Les diagrammes de dispersion sont une autre visualisation utile qui
montre la dépendance des variables. Par exemple, si nous voulons
voir s'il existe une relation positive entre le salaire et l'évaluation
globale du joueur (si le salaire augmente, l'évaluation augmente-t-
elle ?), nous pouvons utiliser le nuage de points pour la trouver.
Avant de générer le nuage de points, nous devons convertir la
colonne des salaires d'une chaîne en virgule flottante, qui est une
colonne numérique. Pour ce faire, une nouvelle colonne est créée,
nommée wage_euro :
df['wage_euro'] = df['Wage'].str.strip('€')

df['wage_euro'] = df['wage_euro'].str.strip('K')

df['wage_euro'] = df['wage_euro'].astype(float)*1000.0
Maintenant, affichons notre nouvelle colonne wage_euro et
la colonne globale :
 print(df[['Overall', 'wage_euro']].head())
Le résultat serait le suivant :
Globalement wage_euro
0 94 565000.0
1 94 405000.0
2 92 290000.0
3 91 260000.0
4 91 355000.0

La génération d'un diagramme de dispersion Matplotlib est aussi

simple que l'utilisation de scatter() sur l'objet plt. Nous pouvons
également étiqueter chaque axe et donner un titre au graphique :
plt.scatter(df['Overall'], df['wage_euro'])

plt.title('Overall vs. Wage')

plt.ylabel('Wage')

plt.xlabel('Overall')

plt.show()
Utilisation de Matplotlib pour générer des
diagrammes à barres
Un autre bon outil de visualisation est le diagramme à barres, utile
pour analyser les catégories de données. Par exemple, en utilisant
notre ensemble de données FIFA19, nous pourrions vouloir examiner
les nationalités les plus courantes, et les diagrammes en barres
peuvent nous aider à le faire. La visualisation des colonnes
catégorielles exige que les valeurs soient d'abord comptées. Nous
pouvons générer un dictionnaire de valeurs de comptage pour
chacune des catégories des colonnes catégorielles à l'aide de la
méthode de comptage. C'est ce que nous allons faire pour la
colonne de la nationalité :
from collections import Counter

print(Counter(df['Nationalité']))
Le résultat serait une longue liste de nationalités, commençant par
les plus valorisées et se terminant par les moins valorisées.
Ce dictionnaire peut être filtré à l'aide d'une méthode appelée
most_common. Dans ce cas, nous demanderons les dix nationalités
les plus courantes, mais si vous voulez voir les moins courantes,
vous pouvez utiliser la méthode least_common :
print(dict(Counter(df['Nationalité']).most_common(10)))
Là encore, le résultat serait un dictionnaire contenant les dix
nationalités les plus courantes dans l'ordre des valeurs les plus
élevées aux valeurs les plus faibles.
Enfin, le diagramme à barres peut être généré en appelant la
méthode bar sur l'objet plt, en transmettant les clés et les valeurs du
dictionnaire :
nationality_dict =
dict(Counter(df['Nationalité']).most_common(10))

plt.bar(nationality_dict.keys(), nationality_dict.values())

plt.xlabel('Nationalité')

plt.ylabel('Fréquence')
 plt.title('Bar Plot of Ten Most Common Nationalities')

plt.xticks(rotation=90)

plt.show()
Vous pouvez voir sur le diagramme à barres résultant que les valeurs
de l'axe des x se chevauchent, ce qui les rend difficiles à voir. Si nous
voulons faire pivoter les valeurs, nous utilisons la méthode xticks(),
comme ceci :
plt.xticks(rotation=90)
Utilisation de Matplotlib pour générer des
diagrammes à secteurs
Les diagrammes circulaires sont un excellent moyen de visualiser les
proportions dans les données. En utilisant notre ensemble de
données FIFA19, nous pouvons visualiser les proportions de joueurs
pour trois pays - l'Angleterre, l'Allemagne et l'Espagne - à l'aide d'un
diagramme circulaire.
Tout d'abord, nous créons quatre nouvelles colonnes, une pour
l'Angleterre, une pour l'Allemagne, une pour l'Espagne et une autre
pour toutes les autres nationalités :
df.loc[df.Nationalité =='Angleterre', 'Nationalité2'] =
'Angleterre'

df.loc[df.Nationalité =='Espagne', 'Nationalité2'] = 'Espagne'

df.loc[df.Nationalité =='Allemagne', 'Nationalité2'] =

'Allemagne'

df.loc[~df.Nationalité.isin(['Angleterre', 'Allemagne',
'Espagne']), 'Nationalité2'] = 'Autre'
 Ensuite, créons un dictionnaire qui contiendra les valeurs de
proportion pour chacun d'entre eux :

prop = dict(Counter(df['Nationalité2']))

pour clé, valeurs dans prop.items() :

prop[key] = (values)/len(df)*100

print(prop)
Le résultat vous montre un dictionnaire ou une liste montrant Other,
Spain et England, avec leurs proportions de joueurs. A partir de là,
nous pouvons utiliser la méthode pie de Matplotlib pour créer un
diagramme circulaire à partir du dictionnaire :
fig1, ax1 = plt.subplots()

ax1.pie(prop.values(), labels=prop.keys(),
autopct='%1.1f%%',

shadow=True, startangle=90)

ax1.axis('equal') # Un rapport d'aspect égal garantit que la

tarte est dessinée comme un cercle.

plt.show()
Comme vous pouvez le constater, ces méthodes nous offrent toutes
des moyens très puissants de visualiser les proportions de catégories
dans les données.
Visualiser les données avec Seaborn
Seaborn est une autre bibliothèque utile, construite sur Matplotlib et
offrant une puissante méthode de formatage des graphiques. Une
fois que vous aurez maîtrisé Matplotlib, vous pourrez passer à
Seaborn pour utiliser des visualisations plus complexes.
Par exemple, nous pouvons utiliser la méthode set() de Seaborn
pour améliorer l'aspect de nos graphiques Matplotlib.
Tout d'abord, Seaborn doit être importé et tous les chiffres générés
précédemment doivent être reformatés. Ajoutez ce qui suit au début
de votre script et exécutez-le :
import seaborn as sns

sns.set()
Utilisation de Seaborn pour générer des
histogrammes
Nous pouvons utiliser Seaborn pour générer les mêmes visualisations
que celles que nous avons générées avec Matplotlib. Tout d'abord,
nous allons générer l'histogramme montrant la colonne globale. Cela
se fait sur l'objet Seaborn avec distplot :
sns.distplot(df['Overall'])
Nous pouvons également réutiliser notre objet plt pour créer des
formats supplémentaires sur l'axe et définir le titre :
plt.xlabel('Overall')

plt.ylabel('Fréquence')

plt.title('Histogramme de l'évaluation globale')

plt.show()
Comme vous pouvez le constater, ce tracé est beaucoup plus beau
que celui généré avec Matplotlib.
Utilisation de Seaborn pour générer des diagrammes
de dispersion
Nous pouvons également utiliser Seaborn pour générer des
diagrammes de dispersion de manière simple :
sns.scatterplot(df['Overall'], df['wage_euro'])

plt.title('Overall vs. Wage')

plt.ylabel('Wage')

plt.xlabel('Overall')

plt.show( )
Utiliser Seaborn pour générer des cartes thermiques
Seaborn est peut-être surtout connu pour sa capacité à créer des
cartes thermiques de corrélation. Celles-ci sont utilisées pour
identifier l'indépendance des variables et, avant de les générer, la
corrélation entre un ensemble spécifié de colonnes numériques doit
être calculée. Nous le ferons pour quatre colonnes :

âge
globale
wage_euro
mouvements de compétences
corr = df[['Overall', 'Age', 'wage_euro', 'Skill Moves']].corr()

sns.heatmap(corr, annot=True)
 plt.title('Heatmap of Overall, Age, wage_euro, and Skill
Moves')

plt.show()
Si nous voulons voir les valeurs de corrélation, annot peut être réglé
sur true :
sns.heatmap(corr, annot=True)
Utilisation de Seaborn pour générer un diagramme de
paires
C'est le dernier outil que nous allons étudier - une méthode appelée
pairplot - qui permet de générer une matrice de distributions, ainsi
qu'un diagramme de dispersion pour un ensemble de
caractéristiques numériques spécifié. Nous le ferons avec trois
colonnes :

âge
globale
potentiel
data = df[['Overall', 'Age', 'Potential',]]

sns.pairplot(data)

plt.show()
Il s'agit de l'un des moyens les plus rapides et les plus faciles de
visualiser les relations entre les variables et les distributions de
valeurs numériques à l'aide de diagrammes de dispersion.
Matplotlib et Seaborn sont tous deux d'excellents outils, très utiles
dans le monde de la data science. Matplotlib vous aide à étiqueter,
titrer et formater les graphiques, l'un des facteurs les plus
importants pour communiquer efficacement vos résultats. Il fournit
également la plupart des outils fondamentaux dont nous avons
besoin pour produire des visualisations, comme les diagrammes de
dispersion, les histogrammes, les diagrammes à barres et les
diagrammes circulaires.
Seaborn est également une bibliothèque très importante parce
qu'elle offre des outils statistiques approfondis et des visuels
étonnants. Comme vous l'avez vu, les graphiques générés par
Seaborn sont beaucoup plus agréables à regarder que ceux de
Matplotlib. Les outils de Seaborn permettent également d'obtenir des
visuels et des analyses plus sophistiqués.
Ces deux bibliothèques sont populaires dans le domaine de la
visualisation de données, car elles permettent toutes deux une
visualisation rapide des données pour raconter des histoires avec les
données. Leurs cas d'utilisation se chevauchent quelque peu, mais il
est judicieux d'apprendre les deux afin de s'assurer que vous faites
le meilleur travail possible avec vos données.
Maintenant, attachez votre ceinture et installez-vous. La partie
suivante est de loin la plus longue, car nous allons nous plonger
dans le sous-ensemble le plus important de la data science : le
machine learning.
Cinquième partie - Un guide approfondi de le
machine learning
Le terme "apprentissage automatique" a été inventé pour la
première fois en 1959 par Arthur Samuel, un pionnier de l'IA et
des jeux informatiques, qui l'a défini comme "un domaine d'étude
qui donne aux ordinateurs la capacité d'apprendre sans
programmation explicite".
Cela signifie que le machine learning est une application de l'IA
qui permet aux logiciels d'apprendre par l'expérience, en
s'améliorant continuellement sans programmation explicite. Par
exemple, pensez à écrire un programme pour identifier les
légumes en fonction de leurs propriétés telles que la forme, la
taille, la couleur, etc.
Vous pourriez tout coder en dur, en ajoutant quelques règles que
vous utiliseriez pour identifier les légumes. Pour certains, cela
pourrait sembler être la seule façon de fonctionner, mais aucun
programmeur ne peut écrire les règles parfaites qui fonctionneront
dans tous les cas. C'est là qu'intervient le machine learning, sans
aucune règle, ce qui le rend plus pratique et plus robuste. Tout au
long de ce chapitre, vous verrez comment le machine learning
peut être utilisé pour cette tâche.
Nous pourrions donc dire que le machine learning est une étude
visant à faire en sorte que les machines présentent un
comportement humain en termes de prise de décision et de
comportement, en leur permettant d'apprendre avec peu
d'intervention humaine - c'est-à-dire sans programmation
explicite. Cela soulève la question suivante : comment une
machine acquiert-elle de l'expérience et d'où apprend-elle ? La
réponse est simple : les données, le carburant qui alimente le
machine learning. Sans elles, il n'y a pas d'apprentissage
automatique.
Encore une question : si le machine learning a été mentionné
pour la première fois en 1959, pourquoi a-t-il mis si longtemps à
se généraliser ? La principale raison en est la puissance de calcul
considérable que le machine learning requiert, sans parler du
matériel capable de stocker de grandes quantités de données. Ce
n'est qu'au cours des dernières années que nous avons atteint les
exigences nécessaires pour pratiquer le machine learning.
Quelles sont les différences entre le machine learning et la
programmation traditionnelle ?
La programmation traditionnelle implique que des données
d'entrée soient introduites dans une machine, accompagnées d'un
programme propre et testé, afin de générer un résultat. Avec le
machine learning, les données d'entrée et de sortie sont
transmises à la machine au cours de la phase initiale, appelée
phase d'apprentissage. À partir de là, la machine élabore elle-
même la programmation.
Ne vous inquiétez pas si cela n'a pas de sens pour l'instant. Au fur
et à mesure que vous avancerez dans ce chapitre approfondi, tout
s'arrangera.
Pourquoi nous avons besoin de le machine learning
De nos jours, le machine learning suscite plus d'intérêt qu'on ne
pourrait le croire. L'une de ses principales utilisations est
l'automatisation des tâches qui requièrent l'intelligence humaine. Les
machines ne peuvent reproduire cette intelligence que par le biais de
le machine learning.
Les entreprises utilisent le machine learning pour automatiser des
tâches et automatiser et créer des modèles d'analyse de données.
Certaines industries dépendent fortement d'énormes quantités de
données qu'elles utilisent pour optimiser les opérations et prendre
les bonnes décisions. Le machine learning permet de créer des
modèles pour traiter et analyser des données complexes en grande
quantité et fournir des résultats précis. Ces modèles sont évolutifs et
précis, et ils fonctionnent rapidement, ce qui permet aux entreprises
de tirer parti de leur énorme puissance et des opportunités qu'elles
offrent tout en évitant les risques, connus ou inconnus.
Parmi les nombreuses utilisations de le machine learning dans le
monde réel, citons la génération de textes, la reconnaissance
d'images, etc.
Comment fonctionne le machine learning ?
Les modèles d'apprentissage automatique sont alimentés par des
données historiques, appelées données d'apprentissage. Ils
apprennent à partir de ces données et construisent ensuite un
algorithme de prédiction qui prédit un résultat pour un ensemble
de données complètement différent, appelé données d'essai, qui
est donné en entrée au système. La précision des modèles dépend
entièrement de la qualité des données et de la quantité de
données fournies - plus il y a de données de qualité, meilleurs
sont les résultats et la précision.
Supposons que nous ayons une question très complexe qui
nécessite des prédictions. Plutôt que d'écrire un code complexe,
nous pourrions confier les données à des algorithmes
d'apprentissage automatique. Ceux-ci développent une logique et
fournissent des prédictions. Nous aborderons les différents types
d'algorithmes dans quelques instants.
Le machine learning d'hier à aujourd'hui
De nos jours, nous voyons de nombreuses preuves de le machine
learning en action, comme le traitement du langage naturel et les
véhicules à conduite autonome, pour n'en citer que deux. Le
machine learning existe cependant depuis plus de 70 ans, et ce
depuis 1943. Warren McCulloch, neuropsychologue, et Water Pitts,
mathématicien, ont publié un article sur les neurones et leur
fonctionnement. Ils ont ensuite créé un modèle avec un circuit
électrique, produisant ainsi le tout premier réseau neuronal.
Alan Turing a créé le test de Turing en 1950. Ce test était utilisé
pour déterminer si les ordinateurs possédaient une réelle
intelligence. Pour réussir le test, l'ordinateur devait tromper un
humain en lui faisant croire qu'il s'agissait d'un humain.
Arthur Samuel a écrit le tout premier programme d'apprentissage
informatique en 1952, un jeu de dames que l'ordinateur améliorait
au fur et à mesure qu'il jouait. Il y est parvenu en étudiant les
mouvements, en déterminant ceux qui s'inscrivaient dans les
stratégies gagnantes et en utilisant ensuite ces mouvements dans
son propre programme.
En 1957, Frank Rosenblatt a conçu le perceptron, un réseau
neuronal pour ordinateurs qui simule les processus de pensée du
cerveau humain. Dix ans plus tard, un algorithme appelé "Nearest
Neighbor" a été créé. Cet algorithme a permis aux ordinateurs de
commencer à utiliser la reconnaissance des formes, même si elle
était très rudimentaire à l'époque. Cet algorithme était idéal pour
permettre aux vendeurs de tracer des itinéraires et de s'assurer
que toutes leurs visites étaient effectuées dans les plus brefs
délais.
C'est dans les années 1990 que les changements les plus
importants sont apparus. Le travail passait d'une approche
presque entièrement fondée sur la connaissance à une approche
davantage axée sur les données. Les scientifiques ont commencé
à créer des programmes permettant aux ordinateurs d'analyser
d'énormes quantités de données et de tirer des conclusions à
partir des résultats obtenus.
En 1997, Deep Blue, créé par IBM, a été le premier joueur
d'échecs informatisé à battre un champion du monde à son propre
jeu. Le programme a recherché les mouvements possibles,
utilisant sa puissance de calcul pour choisir les meilleurs. Dix ans
plus tard, Geoffrey Hinton a inventé le terme d'apprentissage
"profond" pour décrire les nouveaux algorithmes qui permettent
aux ordinateurs de reconnaître du texte et des objets dans des
images et des vidéos.
En 2012, Alex Krizhevzky a publié un article avec Ilya Sutskever et
Geoffrey Hinton. Cet article, qui a eu une grande influence,
décrivait un modèle informatique permettant de réduire
considérablement le taux d'erreur dans les systèmes de
reconnaissance d'images. Dans le même temps, le X Lab de
Google a mis au point un algorithme capable de parcourir les
vidéos YouTube de manière autonome, en choisissant celles qui
contiennent des chats.
En 2016, les chercheurs de Google DeepMind ont créé AlphaGo
pour jouer à l'ancien jeu chinois, le Go, et l'ont opposé au
champion du monde, Lee Sedol. AlphaGo a battu le champion du
monde en titre quatre fois sur cinq.
Enfin, en 2020, GPT-3 a été publié, sans doute le modèle de
langage le plus puissant au monde. Diffusé par l'OpenAI, le
modèle peut générer du code entièrement fonctionnel, écrire de la
fiction créative, rédiger de bons mémos commerciaux, et bien plus
encore, les cas d'utilisation n'étant limités que par l'imagination.
Fonctionnalités de le machine learning
Le machine learning offre de nombreuses fonctionnalités, dont les
plus importantes sont les suivantes :

Automatisation - la plupart des comptes de

messagerie ont un dossier "spam" dans lequel
apparaissent tous les courriels indésirables. Vous vous
demandez peut-être comment votre fournisseur de
services de messagerie sait quels courriels sont des
spams, et la réponse est le machine learning. Le
processus est automatisé une fois que l'algorithme a
appris à reconnaître les courriels indésirables.
La possibilité d'automatiser les tâches répétitives est l'une
des meilleures caractéristiques de le machine learning. De
nombreuses entreprises dans le monde l'utilisent pour
gérer l'automatisation du courrier électronique et de la
paperasserie. Prenons l'exemple du secteur financier.
Chaque jour, de nombreuses tâches répétitives et lourdes
en données doivent être effectuées, et le machine learning
se charge du gros de ce travail, en l'automatisant pour
l'accélérer et en libérant de précieuses heures de travail
pour des tâches plus importantes.

Une meilleure expérience client - de bonnes

relations avec les clients sont essentielles pour les
entreprises, car elles contribuent à promouvoir la
fidélité à la marque et à susciter l'engagement. Et la
meilleure façon pour un client d'y parvenir est de
fournir de meilleurs services et une meilleure
expérience client. Le machine learning entre en jeu
dans ces deux domaines. Pensez à la dernière fois que
vous avez vu des publicités sur internet ou visité un
site d'achat. La plupart du temps, les publicités
correspondent à ce que vous avez recherché, et les
sites d'achat recommandent des produits sur la base
de recherches ou d'achats antérieurs. Le machine
learning est à l'origine de ces systèmes de
recommandation incroyablement précis et permet
d'adapter les expériences à chaque utilisateur.
En termes de services, la plupart des entreprises utilisent
des chatbots pour s'assurer qu'elles sont disponibles 24
heures sur 24 et 7 jours sur 7. Et certains sont si
intelligents que de nombreux clients ne se rendent même
pas compte qu'ils ne discutent pas avec un véritable être
humain.

Visualisation automatisée des données - de nos

jours, d'énormes quantités de données sont générées
quotidiennement par les particuliers et les entreprises,
par exemple Google, Facebook et Twitter. Pensez à la
quantité de données que chacun d'entre eux doit
générer quotidiennement. Ces données peuvent être
utilisées pour visualiser les relations, ce qui permet aux
entreprises de prendre des décisions qui leur sont
 bénéfiques ainsi qu'à leurs clients. Grâce aux
plateformes automatisées de visualisation des
données, les entreprises peuvent obtenir des
informations utiles sur les données et les utiliser pour
améliorer l'expérience et le service à la clientèle.
BI ou Business Intelligence - Lorsque les
caractéristiques de le machine learning sont fusionnées
avec l'analyse des données, en particulier les big data,
les entreprises trouvent plus facilement des solutions
aux problèmes et les utilisent pour développer leurs
activités et augmenter leurs bénéfices. Pratiquement
tous les secteurs utilisent ce type d'apprentissage
automatique pour améliorer leurs opérations.
Avec Python, vous avez la possibilité de choisir entre l'écriture de
scripts et la programmation orientée objet. Il n'est pas nécessaire
de recompiler le code : les modifications peuvent être mises en
œuvre et les résultats s'affichent instantanément. C'est le plus
polyvalent de tous les langages de programmation et il est
multiplateforme, ce qui explique pourquoi il convient si bien à le
machine learning et à la data science.
Les différents types d'apprentissage automatique
Le machine learning se divise en trois catégories principales :

Apprentissage supervisé
Apprentissage non supervisé
Apprentissage par renforcement
Nous examinerons brièvement chaque type avant de nous pencher
sur les algorithmes d'apprentissage automatique les plus
répandus.
Apprentissage supervisé
Nous commencerons par l'exemple le plus simple pour expliquer
l'apprentissage supervisé. Supposons que vous essayez
d'apprendre à votre enfant à faire la différence entre un chat et
un chien. Comment vous y prenez-vous ?
Vous montrez un chien et dites à votre enfant "c'est un chien".
Puis vous faites de même avec un chat. Montrez-lui suffisamment
et il finira par faire la différence. Avec le temps, il pourra même
commencer à reconnaître les différentes races, même s'il ne les a
jamais vues auparavant.
De la même manière, l'apprentissage supervisé fonctionne avec
deux ensembles de variables. L'une est une variable cible ou des
étiquettes, qui est la variable que nous prédisons, tandis que
l'autre est la variable des caractéristiques, qui sont celles qui nous
aident à faire les prédictions. Les caractéristiques et les étiquettes
qui les accompagnent sont présentées au modèle, qui trouve alors
des modèles dans les données qu'il examine. Pour clarifier les
choses, voici un exemple tiré d'un ensemble de données sur les
prix de l'immobilier. Nous voulons prédire le prix d'un logement en
fonction de sa taille. La variable cible est le prix et la
caractéristique dont elle dépend est la taille.
Nombre de chambres Prix
1
3
5
Les ensembles de données réels comportent des milliers de lignes
et de multiples caractéristiques, telles que la taille, le nombre
d'étages, l'emplacement, etc.
La façon la plus simple d'expliquer l'apprentissage supervisé est
donc de dire que le modèle a x, qui est un ensemble de variables
d'entrée, et y, qui est la variable de sortie. Un algorithme est
utilisé pour trouver la fonction de correspondance entre x et y, et
la relation est y = f(x).
On parle d'apprentissage supervisé parce que nous savons déjà
quel sera le résultat et que nous le fournissons à la machine. À
chaque exécution, l'algorithme est corrigé, et ce jusqu'à ce que
nous obtenions les meilleurs résultats possibles. L'ensemble des
données est utilisé pour former l'algorithme à un résultat optimal.
Les problèmes d'apprentissage supervisé peuvent être regroupés
comme suit :

Régression - prédit les valeurs futures. Les données

historiques sont utilisées pour former le modèle, et la
prédiction serait la valeur future d'un bien immobilier,
par exemple.
Classification - l'algorithme est entraîné sur
différentes étiquettes pour identifier les objets d'une
catégorie particulière, par exemple les chats ou les
chiens, les oranges ou les pommes, etc.
Apprentissage non supervisé
L'apprentissage non supervisé n'implique aucune variable cible. La
machine ne reçoit que les caractéristiques à partir desquelles elle
doit apprendre, ce qu'elle fait seule et trouve des structures dans
les données. L'idée est de trouver la distribution qui sous-tend les
données afin d'en apprendre davantage sur celles-ci.
L'apprentissage non supervisé peut être regroupé comme suit :

Regroupement - les variables d'entrée partageant

des caractéristiques sont regroupées, c'est-à-dire tous
les utilisateurs qui recherchent les mêmes choses sur
l'internet.
Association - les règles régissant les associations
significatives de données sont découvertes, c'est-à-dire
 que si une personne regarde ceci, il est probable
qu'elle regarde aussi cela.
Apprentissage par renforcement
Dans l'apprentissage par renforcement, les modèles sont entraînés à
prendre des décisions sur la base d'un système de
récompense/rétroaction. On les laisse apprendre comment atteindre
un objectif dans des situations complexes et, chaque fois qu'ils
atteignent l'objectif au cours de l'apprentissage, ils sont
récompensés.
Il diffère de l'apprentissage supervisé dans la mesure où il n'y a pas
de réponse disponible, de sorte que l'agent détermine les étapes
nécessaires à l'accomplissement de la tâche. La machine utilise ses
propres expériences pour apprendre lorsqu'aucune donnée de
formation n'est fournie.
Algorithmes courants d'apprentissage automatique
Il existe beaucoup trop d'algorithmes d'apprentissage automatique
pour pouvoir tous les mentionner, mais nous pouvons parler des plus
courants que vous êtes susceptible d'utiliser. Nous verrons plus tard
comment utiliser certains de ces algorithmes dans des exemples
d'apprentissage automatique, mais pour l'instant, voici un aperçu
des plus courants.
Algorithme de classification Naïve Bayes
Le classificateur Naïve Bayes n'est pas un algorithme unique. Il
s'agit d'une famille d'algorithmes de classification, tous basés sur le
théorème de Bayes. Ils partagent tous un principe commun :
chaque paire de caractéristiques à classer est indépendante l'une
de l'autre.
Nous allons nous pencher directement sur ce sujet à l'aide d'un
exemple.
Utilisons un ensemble de données fictives décrivant les conditions
météorologiques pour décider de jouer ou non au golf. Compte
tenu d'une condition spécifique, la classification est Oui (apte à
jouer) ou Non (inapte à jouer).
L'ensemble de données ressemble à ceci :
Perspectives Température Humidité V
ent Jouer au golf
0 Pluvieux Chaud Élevé Faux
Non
1 Pluvieux Chaud Élevé Vrai
Non
2 Ciel
couvert Chaud Haut Faux Oui
3 Ensoleillé Élevé Faux
Oui
4 Ensoleillé Frais Normal Faux
Oui
5 Ensoleillé Frais Normal Vrai
Non
6 Couvert Frais Normal Vrai
Oui
7 Pluvieux Élevé Faux
Non
8 Pluvieux Frais Normal Faux
Oui
9 Ensoleillé Normal Faux
Oui
10 Pluvieux Normal Vrai
Oui
11 Ciel
couvert Élevé Vrai Oui
12 Couvert Chaud Normal Faux
Oui
13 Ensoleillé Élevé Vrai
Non
Cet ensemble de données est divisé en deux :

Matrice des caractéristiques - où sont stockées

toutes les lignes de l'ensemble de données (vecteurs) -
les vecteurs contiennent les valeurs des caractéristiques
dépendantes. Dans notre ensemble de données, les
quatre caractéristiques sont les suivantes : perspectives,
température, vent et humidité.
Vecteur de réponse - où toutes les valeurs de la
variable de classe, c'est-à-dire la prédiction ou la sortie,
sont stockées pour chaque ligne de la matrice de
caractéristiques. Dans notre ensemble de données, la
variable de classe s'appelle Jouer au golf.
Hypothèse
Les classificateurs Naïve Bayes reposent sur l'hypothèse que toutes
les caractéristiques apporteront au résultat une contribution égale
et indépendante. En ce qui concerne notre ensemble de données,
nous pouvons comprendre cela comme suit :

Hypothèse selon laquelle il n'y a pas de dépendance

entre les paires de caractéristiques. Par exemple, une
température classée comme chaude est indépendante
de l'humidité, et une perspective pluvieuse n'est pas liée
au vent. Nous supposons donc que les caractéristiques
sont indépendantes.
Chaque caractéristique a la même importance (poids).
Par exemple, si vous ne connaissez que l'humidité et la
 température, vous ne pouvez pas fournir une prédiction
précise. Aucun attribut n'est considéré comme non
pertinent et tous jouent un rôle égal dans la
détermination du résultat.
Théorème de Bayes
Le théorème de Bayes utilise la probabilité d'un événement qui
s'est déjà produit pour déterminer la probabilité d'un autre
événement. Le théorème s'énonce mathématiquement comme suit
:

A et B sont tous deux des événements et P(B)?0 :

Nous voulons prédire la probabilité de l'événement A si

l'événement B est vrai. L'événement B est également
appelé preuve.
P(A) est la probabilité préalable de A, c'est-à-dire la
probabilité qu'un événement se produise avant toute
preuve. Cette preuve consiste en une valeur d'attribut
d'une instance inconnue - dans notre cas, il s'agit de
l'événement B.
P(A|B) est appelé probabilité a posteriori de B, ou
probabilité qu'un événement se produise une fois que
les preuves ont été vues.
Nous pouvons appliquer le théorème à notre ensemble de données
de la manière suivante :

La variable de classe est y et le vecteur de caractéristiques

dépendant, de taille n, est X, où
Pour clarifier les choses, voici un exemple de vecteur de
caractéristiques et de variable de classe correspondante :
X = (pluvieux, chaud, élevé, faux)
y = Non
Ici, P(y|X) indique la probabilité de ne pas jouer, compte tenu d'un
ensemble de conditions météorologiques comme suit :

Perspectives pluvieuses
Température élevée
Humidité élevée
Pas de vent
Hypothèse naïve
Donner au théorème de Bayes une hypothèse naïve signifie fournir
une indépendance entre les caractéristiques. La preuve peut
maintenant être divisée en ses parties indépendantes. Si deux
événements quelconques, A et B, sont indépendants :
P(A,B) = P(A)P(B)
Le résultat est le suivant :

Et ceci est exprimé comme suit :

Pour une entrée donnée, le dénominateur reste constant, de sorte

que ce terme peut être supprimé :

L'étape suivante consiste à créer un modèle de classification. Nous

déterminerons la probabilité d'un ensemble d'entrées donné pour
toutes les valeurs possibles de la variable de classe y, en
choisissant la sortie qui offre la probabilité maximale. Cela
s'exprime mathématiquement comme suit :

Il nous reste donc à calculer P(y) et P(xi | y).

P(y) est également appelé probabilité de classe, et P(xi | y) est la

probabilité conditionnelle.
Il existe plusieurs classificateurs Naïve Bayes, dont la principale
différence réside dans les hypothèses relatives à la distribution P(xi
| y).
Appliquons manuellement cette formule à notre ensemble de
données météorologiques. Nous devons effectuer quelques calculs
préalables, c'est-à-dire que pour chaque xi dans X et yi dans y,
nous devons trouver P(X=xi | yi ). Ces calculs sont présentés dans
les tableaux suivants :
P(X=xi | yi ) est calculé pour chaque xi dans X et yi dans y
manuellement dans les tableaux ci-dessus. Par exemple, nous
calculons la probabilité de jouer si la température est fraîche -
P(temp. = fraîche | jouer or = oui = 3/9.
Nous avons également besoin des probabilités de la classe (P(y)),
calculées dans le tableau final ci-dessus. Par exemple, les
probabilités sont calculées comme suit : P(jouer l'or = oui) = 9/14.
Maintenant que le classificateur est prêt à fonctionner, nous allons
le tester sur un ensemble de caractéristiques que nous appellerons
"aujourd'hui".
aujourd'hui = (Ensoleillé, Chaud, Normal, Faux)
Dans ces conditions, la probabilité de jouer est de :

Et ne pas jouer l'est :

P(aujourd'hui) apparaît dans les deux probabilités, nous pouvons

donc l'ignorer et rechercher les probabilités proportionnelles :

et

Parce que

Nous pouvons faire en sorte que la somme soit égale à 1 pour

convertir les chiffres en probabilité - c'est ce qu'on appelle la
normalisation :

et

Parce que
Dans ce cas, nous prévoyons que Oui, il y aura du golf.
Nous avons discuté d'une méthode que nous pouvons utiliser pour
les données discrètes. Si nous travaillons avec des données
continues, nous devons faire des hypothèses sur la distribution des
valeurs de chaque caractéristique.
Nous allons parler de l'un des classificateurs populaires, Naïve
Bayes.
Classificateur gaussien Naive Bayes
Dans ce classificateur, l'hypothèse est que les valeurs continues
associées à chaque caractéristique sont distribuées selon une
distribution gaussienne, également connue sous le nom de
distribution normale. Lorsque cette distribution est tracée, on
observe une courbe en forme de cloche, symétrique par rapport à
la moyenne des valeurs des caractéristiques.
L'hypothèse est que la probabilité des caractéristiques est
gaussienne, ce qui signifie que la probabilité conditionnelle est
fournie via :

Voyons à quoi ressemble une implémentation Python de ce

classificateur en utilisant Scikit-learn :
# charger l'ensemble de données sur l'iris
from sklearn.datasets import load_iris
iris = load_iris()

# stocker la matrice des caractéristiques (X) et le vecteur

de réponse (y)
X = iris.data
 y = iris.target

# diviser X et y en ensembles d'apprentissage et de test

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.4, random_state=1)

# entraînement du modèle sur l'ensemble d'entraînement

from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(X_train, y_train)

# faire des prédictions sur l'ensemble des tests

y_pred = gnb.predict(X_test)

# comparaison des valeurs de réponse réelles (y_test) avec

les valeurs de réponse prédites (y_pred)
from sklearn import metrics
print("Gaussian Naive Bayes model accuracy(in %) :",
metrics.accuracy_score(y_test, y_pred)*100)
Et le résultat est le suivant :
Précision du modèle Gaussian Naive Bayes (en %) : 95.0
Voisins les plus proches (K-Nearest Neighbors)
K-Nearest Neighbors, également connu sous le nom de K-NN, est un
algorithme de classification critique mais simple. Il s'agit d'un
algorithme d'apprentissage supervisé utilisé pour l'exploration de
données, la détection de modèles et la détection d'intrusions.
Dans les scénarios de la vie réelle, elle est considérée comme jetable
parce qu'elle est non paramétrique, ce qui signifie qu'elle ne fait
aucune hypothèse sous-jacente sur la distribution des données.
Certaines données antérieures, les données d'apprentissage, sont
fournies et des attributs sont utilisés pour classer les coordonnées
dans des groupes spécifiques.
Voici un exemple de tableau contenant quelques points de données
et deux caractéristiques :

Avec un autre ensemble de points de données, appelés données de

test, nous pouvons analyser les données et répartir les points dans
un groupe. Les points non classés du tableau sont marqués "Blanc".
Intuition
Si ces points étaient représentés sur un graphique, nous pourrions
observer des groupes ou des grappes. Les points non classés
peuvent être affectés à un groupe simplement en voyant dans quel
groupe se trouvent les voisins les plus proches du point non classé.
Cela signifie qu'un point situé à proximité d'un groupe classé "rouge"
a plus de chances d'être classé "rouge".
Par intuition, il est clair que le premier point (2,5, 7) devrait être
classé "vert", tandis que le second (5,5, 4,5) devrait être classé
"rouge".
Algorithme
Ici, m indique le nombre d'échantillons d'apprentissage dont nous
disposons et p est un point inconnu. Voici ce que nous voulons faire
:

1. Les échantillons d'apprentissage sont stockés dans arr[],

qui est un tableau contenant des points de données.
 Chaque élément du tableau représente (x, y), qui est un
tuple.
Pour i=0 à m

2. Calculer d(arr[i], p), qui est la distance euclidienne.

3. L'ensemble S de K devrait correspondre aux plus petites
distances retrouvées. Chaque distance correspond à un
point de données que nous avons déjà classé.
4. L'étiquette majoritaire parmi S est renvoyée.
Nous pouvons conserver K comme un nombre impair, ce qui facilite
le calcul de la majorité claire lorsqu'il n'y a que deux groupes
possibles. Au fur et à mesure que K augmente, les limites entre les
classifications deviennent plus définies et plus lisses. Et plus le
nombre de points de données augmente dans l'ensemble de
formation, plus la précision du classificateur s'améliore.
Voici un exemple de programme, écrit en C++ et en Python, où 0 et
1 sont les classificateurs: :
// Programme C++ pour trouver des groupes d'inconnus
// Points utilisant l'algorithme du plus proche voisin K.
#include <bits/stdc++.h>
using namespace std ;

struct Point
{
int val ; // Groupe de points
double x, y ; // Coordonnées du point
double distance ; // Distance du point de test
};
// Utilisé pour trier un tableau de points par ordre croissant.
// ordre de distance
bool comparison(Point a, Point b)
{
return (a.distance < b.distance) ;
}

// Cette fonction détermine la classification du point p à

l'aide de
// algorithme des k plus proches voisins. Il ne suppose que
deux
// groupes et renvoie 0 si p appartient au groupe 0, sinon
// 1 (appartient au groupe 1).
int classifyAPoint(Point arr[], int n, int k, Point p)
{
// Remplir les distances de tous les points par rapport à p
for (int i = 0 ; i < n ; i++)
arr[i].distance =
sqrt((arr[i].x - p.x) * (arr[i].x - p.x) +
(arr[i].y - p.y) * (arr[i].y - p.y)) ;

// Classer les points en fonction de leur distance par

rapport à p
sort(arr, arr+n, comparison) ;
 // Considérons maintenant les k premiers éléments et
seulement
// deux groupes
int freq1 = 0 ; // Fréquence du groupe 0
int freq2 = 0 ; // Fréquence du groupe 1
for (int i = 0 ; i < k ; i++)
{
si (arr[i].val == 0)
freq1++ ;
else if (arr[i].val == 1)
freq2++ ;
}

return (freq1 > freq2 ? 0 : 1) ;

}

// Code du conducteur
int main()
{
int n = 17 ; // Nombre de points de données
Point arr[n] ;

arr[0].x = 1 ;
arr[0].y = 12 ;
arr[0].val = 0 ;
arr[1].x = 2 ;
arr[1].y = 5 ;
arr[1].val = 0 ;

arr[2].x = 5 ;
arr[2].y = 3 ;
arr[2].val = 1 ;

arr[3].x = 3 ;
arr[3].y = 2 ;
arr[3].val = 1 ;

arr[4].x = 3 ;
arr[4].y = 6 ;
arr[4].val = 0 ;

arr[5].x = 1.5 ;
arr[5].y = 9 ;
arr[5].val = 1 ;

arr[6].x = 7 ;
arr[6].y = 2 ;
arr[6].val = 1 ;

arr[7].x = 6 ;
arr[7].y = 1 ;
arr[7].val = 1 ;

arr[8].x = 3.8 ;
arr[8].y = 3 ;
arr[8].val = 1 ;

arr[9].x = 3 ;
arr[9].y = 10 ;
arr[9].val = 0 ;

arr[10].x = 5.6 ;
arr[10].y = 4 ;
arr[10].val = 1 ;

arr[11].x = 4 ;
arr[11].y = 2 ;
arr[11].val = 1 ;

arr[12].x = 3.5 ;
arr[12].y = 8 ;
arr[12].val = 0 ;

arr[13].x = 2 ;
arr[13].y = 11 ;
arr[13].val = 0 ;

arr[14].x = 2 ;
 arr[14].y = 5 ;
arr[14].val = 1 ;

arr[15].x = 2 ;
arr[15].y = 9 ;
arr[15].val = 0 ;

arr[16].x = 1 ;
arr[16].y = 7 ;
arr[16].val = 0 ;

/*Point de test*/
Point p ;
p.x = 2,5 ;
p.y = 7 ;

// Paramètre permettant de déterminer le groupe du point

d'essai
int k = 3 ;
printf ("La valeur classée au point inconnu"
"est %d.\n", classifyAPoint(arr, n, k, p)) ;
retour 0 ;
}
Et le résultat est le suivant :
La valeur classée au point inconnu est 0.
Algorithme d'apprentissage de la machine à vecteur
de support
Les machines à vecteurs de support ou SVM font partie des
algorithmes d'apprentissage supervisé utilisés pour analyser les
données dans le cadre d'analyses de régression et de classification.
Le SVM est considéré comme un classificateur discriminant, défini
formellement par un hyperplan de séparation. En termes simples,
avec des données d'apprentissage étiquetées, la partie
apprentissage supervisé, la sortie sera un hyperplan optimal qui
prend de nouveaux exemples et les catégorise.
Les SVM représentent les exemples comme des points dans l'espace.
Chaque point est cartographié de manière à ce que les catégories
distinctes soient séparées par un espace large et clair. Outre la
classification linéaire, un SVM peut également être utilisé pour une
classification non linéaire efficace, les entrées étant implicitement
cartographiées dans des espaces de caractéristiques à haute
dimension.
Que fait donc un SVM ?
Lorsque vous fournissez à un algorithme SVM des exemples
d'apprentissage, chacun étant étiqueté comme appartenant à l'une
des deux catégories, il construit un modèle qui affecte les exemples
nouvellement fournis à l'une des catégories. Il s'agit donc d'une
"classification linéaire binaire non probabiliste".
Pour illustrer cela, nous utiliserons un modèle SVM qui utilise des
outils de ML, comme Scikit-learn, pour classifier les ensembles de
données UCI sur le cancer. Pour cela, vous devez disposer de
NumPy, Pandas, Matplotlib et Scikit-learn.
Tout d'abord, le jeu de données doit être créé :
# importation de scikit learn avec make_blobs
from sklearn.datasets.samples_generator import make_blobs
 # création d'ensembles de données X contenant
n_échantillons
# Y contenant deux classes
X, Y = make_blobs(n_samples=500, centers=2,
random_state=0, cluster_std=0.40)
import matplotlib.pyplot as plt
# tracer les nuages de points
plt.scatter(X[ :, 0], X[ :, 1], c=Y, s=50, cmap='spring') ;
plt.show()
Les machines à vecteurs de support ne se contentent pas de tracer
des lignes entre les classes. Elles considèrent également une région
autour de la ligne d'une largeur spécifiée. En voici un exemple :
# création d'un interligne entre -1 et 3,5
xfit = np.linspace(-1, 3.5)

# tracé du nuage de points

plt.scatter(X[ :, 0], X[ :, 1], c=Y, s=50, cmap='spring')

# tracer une ligne entre les différents ensembles de données

pour m, b, d dans [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2,
2.9, 0.2)] :
yfit = m * xfit + b
plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4)
 plt.xlim(-1, 3.5) ;
plt.show()
Importation d'ensembles de données
L'intuition des SVM est d'optimiser des modèles discriminants
linéaires représentant la distance entre les ensembles de données,
qui est une distance perpendiculaire. Utilisons nos données
d'entraînement pour entraîner le modèle. Avant cela, les ensembles
de données sur le cancer doivent être importés sous la forme d'un
fichier CSV, et nous allons entraîner deux de toutes les
caractéristiques :
# importation des bibliothèques nécessaires
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# lecture du fichier csv et extraction de la colonne classe

vers y.
x = pd.read_csv("C:\N-...\Ncancer.csv")
a = np.array(x)
y = a[ :,30] # classes ayant 0 et 1

# extraire deux caractéristiques

x = np.column_stack((x.malignant,x.benign))

# 569 échantillons et 2 caractéristiques

x.forme

print (x),(y)
Le résultat serait le suivant :
[[ 122.8 1001. ]
[ 132.9 1326. ]
[ 130. 1203. ]
...,
[ 108.3 858.1 ]
[ 140.1 1265. ]
[ 47.92 181. ]]

array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0..,
0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,
0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 1., 1.,
1., 0., 0., 1., 0., 0., 1., 1., 1., 1., 0., 1., ....,
1.])
Ajustement des machines à vecteurs de support
Ensuite, nous devons adapter le classificateur aux points.
# Importation d'un classificateur à vecteur de support
# "Support Vector Classifier"
from sklearn.svm import SVC
clf = SVC(kernel='linear')

# fitting x samples and y classes

clf.fit(x, y)
Une fois le modèle ajusté, il peut être utilisé pour faire des
prédictions sur de nouvelles valeurs :
clf.predict([[120, 990]])

clf.predict([[85, 550]])
array([ 0.])
array([ 1.])
Les données et les méthodes de prétraitement sont analysées, et
Matplotlib est utilisé pour produire des hyperplans optimaux.
Algorithme d'apprentissage automatique de
régression linéaire
Vous avez certainement entendu parler de la régression linéaire, car
c'est l'un des algorithmes d'apprentissage automatique les plus
populaires. Il s'agit d'une méthode statistique utilisée pour modéliser
les relations entre une variable dépendante et un ensemble
spécifique de variables indépendantes. Dans cette section, la
variable dépendante est appelée réponse et les variables
indépendantes sont appelées caractéristiques.
Régression linéaire simple
Il s'agit de la forme la plus élémentaire de régression linéaire,
utilisée pour prédire des réponses à partir de caractéristiques
uniques. Ici, l'hypothèse est qu'il existe une relation linéaire entre
deux variables. Nous voulons donc une fonction linéaire capable de
prédire la valeur de la réponse (y) avec autant de précision qu'en
fonction de la variable indépendante (x) ou de la caractéristique.
Examinons un ensemble de données avec une valeur de réponse
pour chaque caractéristique :
x 0 1 2 3 4 5 6 7 8 9
y 1 3 2 5 7 8 8 9 10 12
Nous définissons ce qui suit par souci de généralité :

x est défini comme un vecteur de caractéristiques, c'est-

à-dire x = [x_1, x_2, ...., x_n]
y est défini comme un vecteur de réponse, c'est-à-dire y
= [y_1, y_2, ...., y_n]
Ils sont définis pour n observations, c'est-à-dire n=10.
La tâche du modèle consiste à trouver la meilleure ligne
d'ajustement pour prédire les réponses pour les nouvelles valeurs
des caractéristiques, c'est-à-dire les caractéristiques qui ne figurent
pas déjà dans l'ensemble de données. La ligne est connue sous le
nom de ligne de régression et son équation est représentée comme
suit :

Ici :

h(x_1) représente la réponse prédite de la ième

observation
b_0 et b_1 sont tous deux des coefficients et
représentent respectivement l'ordonnée à l'origine et la
pente de la droite de régression.
La création du modèle exige que nous estimions ou apprenions les
valeurs des coefficients, et une fois qu'ils ont été estimés, le modèle
peut prédire la réponse.
Nous utiliserons le principe de la méthode des moindres carrés :

Dans ce cas, e_i est l'erreur résiduelle de la ième observation et

nous voulons réduire l'erreur résiduelle totale.
La fonction de coût ou erreur quadratique est définie comme suit :
Nous voulons trouver les valeurs b_0 et b_1, où J(b_1, b_1) est le
minimum.
Sans vous donner tous les détails mathématiques, voici le résultat :

Ici, SS_xy représente la somme de y et x (les écarts croisés) :

SS_xx représente la somme de x, les écarts au carré :

Examinons l'implémentation Python de notre jeu de données :

import numpy as np
import matplotlib.pyplot as plt

def estimate_coef(x, y) :
# Nombre d'observations/points
n = np.size(x)

# Moyenne des vecteurs x et y

m_x = np.mean(x)
m_y = np.mean(y)

# calcul de l'écart croisé et de l'écart par rapport à x

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x
 # calcul des coefficients de régression
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x

retour (b_0, b_1)

def plot_regression_line(x, y, b) :
# tracer les points réels sous forme de nuage de points
plt.scatter(x, y, color = "m",
marqueur = "o", s = 30)

# vecteur de réponse prédit

y_pred = b[0] + b[1]*x

# tracer la ligne de régression

plt.plot(x, y_pred, color = "g")

# mettre des étiquettes

plt.xlabel('x')
plt.ylabel('y')

# fonction pour afficher le graphique

plt.show()

def main() :
# observations / données
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])

# Estimation des coefficients

b = estimate_coef(x, y)
print("Coefficients estimés:\nb_0 = {} \
\nb_1 = {}".format(b[0], b[1]))

# tracer la ligne de régression

plot_regression_line(x, y, b)

si __name__ == "__main__" :
main()
Et le résultat est le suivant :
Coefficients estimés :
b_0 = -0.0586206896552
b_1 = 1.45747126437
Régression linéaire multiple
La régression linéaire multiple tente de modéliser les relations entre
au moins deux caractéristiques et une réponse, et pour ce faire, une
équation linéaire est ajustée aux données observées. Elle n'est rien
de plus complexe qu'une extension de la régression linéaire simple.
Supposons que nous ayons un ensemble de données contenant p
variables indépendantes ou caractéristiques et une variable
dépendante ou réponse. L'ensemble de données comporte n lignes
(observations).
Nous définissons ce qui suit :
 X (matrice des caractéristiques) = une matrice de taille n
X p où x_{ij} est utilisé pour désigner les valeurs de la
jème caractéristique de la ième observation.
Donc

Et

y (vecteur de réponse) = un vecteur de taille n, où y_{i}

désigne la valeur de la réponse de la ième observation

La ligne de régression des caractéristiques p est représentée comme

suit :

Où h(x_i) est la réponse prédite de la ième observation, et les

coefficients de régression sont b_0, b_1, ...., b_p.
Nous pouvons également écrire :

L'erreur résiduelle de la ième observation est représentée par e_i.

En présentant les caractéristiques de la matrice comme suit, le
modèle linéaire peut être généralisé un peu plus :

Le modèle linéaire peut maintenant être exprimé comme suit en

termes de matrices :

où

et

L'estimation de b peut maintenant être déterminée à l'aide de la

méthode des moindres carrés, qui est utilisée pour déterminer b là
où les erreurs résiduelles totales sont minimisées. Le résultat est le
suivant :

Où‘ représente la transposition de la matrice, et l'inverse est

représenté par -1.
Maintenant que l'estimation des moindres carrés, b', est connue,
nous pouvons estimer les modèles de régression linéaire multiple
comme suit :

Le vecteur de réponse estimé est y.

Voici un exemple Python de régression linéaire multiple sur
l'ensemble des données relatives aux prix des logements à Boston :
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

# charger le jeu de données boston

boston = datasets.load_boston(return_X_y=False)

# Définition de la matrice des caractéristiques (X) et du

vecteur de réponse (y)
X = boston.data
y = boston.target

# diviser X et y en ensembles d'apprentissage et de test

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.4,
état_aléatoire=1)

# créer un objet de régression linéaire

reg = linear_model.LinearRegression()
# entraîner le modèle à l'aide des ensembles d'entraînement
reg.fit(X_train, y_train)

# Coefficients de régression
print('Coefficients : ', reg.coef_)

# score de variance : 1 signifie une prédiction parfaite

print('Variance score : {}'.format(reg.score(X_test, y_test)))

# tracé de l'erreur résiduelle

## définir le style de l'intrigue

plt.style.use('fivethirtyeight')

## Représentation graphique des erreurs résiduelles dans

les données d'apprentissage
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
color = "green", s = 10, label = 'Train data')

## Représentation graphique des erreurs résiduelles dans

les données de test
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
color = "blue", s = 10, label = 'Test data')

## tracé de la ligne pour une erreur résiduelle nulle

plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)

## légende du tracé
 plt.legend(loc = 'upper right')

## titre de l'intrigue
plt.title("Erreurs résiduelles")

## appel de méthode pour afficher le graphique

plt.show()
Et le résultat est le suivant :
Coefficients :
[ -8.80740828e-02 6.72507352e-02 5.10280463e-02
2.18879172e+00
-1,72283734e+01 3,62985243e+00 2,13933641e-03
-1,36531300e+00
2,88788067e-01 -1,22618657e-02 -8,36014969e-01
9,53058061e-03
-5.05036163e-01]
Score de variance : 0.720898784611
Dans cet exemple, le score de variance expliquée est utilisé pour
déterminer le score de précision.
Nous avons défini :
score_variance_expliquée = 1 - Var{y - y'}/Var{y}
Dans ce cas, la production cible estimée est y', la production cible
correcte est y, et la variance est VAR, c'est-à-dire l'écart-type au
carré. 1,0 est le meilleur score, tout ce qui est inférieur est moins
bon.
Hypothèses
Il s'agit des hypothèses formulées par un modèle de régression
linéaire sur l'ensemble de données auquel il est appliqué :

Relation linéaire - il doit y avoir une relation linéaire

entre la réponse et les variables caractéristiques. Des
diagrammes de dispersion peuvent être utilisés pour
tester l'hypothèse de linéarité.
Peu ou pas de multicolinéarité - cela se produit
lorsque les variables indépendantes ne sont pas
indépendantes les unes des autres.
Peu ou pas d'auto-corrélation - cela se produit
lorsqu'il n'y a pas d'indépendance entre les erreurs
résiduelles.
Homoscédasticité - c'est lorsque le terme d'erreur est
le même pour toutes les variables indépendantes. Il
s'agit d'une perturbation aléatoire ou d'un bruit dans la
relation entre les variables indépendantes et
dépendantes.
Algorithme d'apprentissage automatique de
régression logistique
La régression logistique est une autre technique d'apprentissage
automatique issue du domaine des statistiques et constitue la
meilleure solution pour résoudre les problèmes de classification
binaire, où il y a deux valeurs de classe. Elle doit son nom à la
fonction qui se trouve au centre de la méthode, appelée fonction
logistique.
Vous la connaissez peut-être aussi sous le nom de fonction sigmoïde.
Elle a été développée pour décrire les propriétés de croissance de la
population en écologie, augmentant rapidement et atteignant son
maximum à la capacité de charge de l'environnement. Une courbe
en S prend des nombres (valeurs réelles) et les fait correspondre à
des valeurs comprises entre 0 et 1, mais pas exactement.
1 / (1 + e^-valeur)
E est la base du logarithme naturel, tandis que la valeur est la valeur
numérique à transformer. Voyons comment la fonction logistique est
utilisée dans la régression logistique.
Représentation
La représentation utilisée par la régression logistique est une
équation similaire à la régression linéaire. Les valeurs d'entrée, x,
sont combinées linéairement à l'aide de coefficients ou de poids pour
prédire y, la valeur de sortie. Elle diffère de la régression linéaire en
ce que la valeur de sortie modélisée est binaire, c'est-à-dire 0 ou 1,
et non numérique.
Voici un exemple d'algorithme de régression logistique :
y = e^(b0 + b1*x) / (1 + e^(b0 + b1*x))
La sortie prédite est y, l'intercept ou le biais est b0, et le coefficient
pour x, la valeur d'entrée, est b1. Un coefficient b est associé à
chaque colonne de données d'entrée. Ce coefficient est une valeur
réelle constante que le modèle apprend à partir des données
d'apprentissage.
Les coefficients que vous voyez dans l'équation sont la
représentation réelle du modèle stockée dans un fichier ou dans la
mémoire.
Probabilité Prédiction
La régression logistique est utilisée pour modéliser la probabilité de
la classe par défaut. Par exemple, disons que nous modélisons le
sexe (masculin ou féminin) en fonction de la taille d'une personne.
Dans ce cas, la classe par défaut peut être masculine et le modèle
est écrit pour la probabilité d'un homme, compte tenu d'une certaine
taille. Plus formellement, ce serait :
P(sexe=homme|taille)
Nous pourrions l'écrire d'une autre manière et dire que le modèle
concerne la probabilité que X, une entrée, appartienne à Y=1, la
classe par défaut. Cela pourrait s'écrire formellement comme suit :
P(X) = P(Y=1|X)
Il faut savoir que la prédiction doit être transformée en valeurs
binaires, 0 ou 1, pour pouvoir la réaliser.
La régression logistique peut être linéaire, mais la fonction logistique
est utilisée pour transformer les prédictions. Cela signifie que les
prédictions ne peuvent plus être considérées comme des
combinaisons linéaires d'entrées, comme c'est le cas avec la
régression linéaire. En reprenant ce qui précède, nous pouvons
énoncer ce modèle comme suit :
p(X) = e^(b0 + b1*X) / (1 + e^(b0 + b1*X))
Sans aller trop loin dans les mathématiques, l'équation ci-dessus
peut être retournée comme suit, sans oublier que e peut être
supprimé d'un côté avec l'ajout de ln, un logarithme naturel, de
l'autre côté :
ln(p(X) / 1 - p(X)) = b0 + b1 * X
Ceci est utile car cela nous permet de voir que le calcul de la sortie
du côté droit est linéaire, alors que l'entrée du côté gauche est un
logarithme de la probabilité de la classe par défaut.
Le rapport de droite est connu sous le nom de cote de la classe par
défaut plutôt que de probabilité. Nous calculons les probabilités
comme un ratio de la probabilité de l'événement, divisé par la
probabilité que l'événement ne se produise pas, par exemple,
0,8/(1-0,8). La probabilité de cet événement étant de 4, nous
pourrions écrire ce qui suit à la place :
ln(chances) = b0 + b1 * X
Comme les probabilités sont transformées en logarithme, le côté
gauche est appelé probit ou logarithme des probabilités.
L'exposant peut être déplacé à nouveau vers la droite et s'écrire
comme suit :
chances = e^(b0 + b1 * X)
Cela nous permet de voir que notre modèle est toujours linéaire
dans sa combinaison de sortie, mais que la combinaison est liée aux
log-odds de la classe par défaut.
Un modèle de régression logistique
Vous devez utiliser vos données d'apprentissage pour estimer les
coefficients de l'algorithme de régression logistique (valeurs bêta b).
Pour ce faire, on utilise l'estimation du maximum de vraisemblance.
Il s'agit de l'un des algorithmes d'apprentissage les plus courants,
utilisé par de nombreux autres algorithmes, mais il convient de noter
qu'il émet des hypothèses sur la distribution de vos données.
Les meilleurs coefficients nous donneraient un modèle qui prédit des
valeurs aussi proches que possible de 1 pour notre classe par défaut
et aussi proches que possible de 0 pour l'autre classe. Dans ce cas,
l'intuition du maximum de vraisemblance pour la régression
logistique est qu'une procédure de recherche recherche les valeurs
des coefficients qui minimisent l'erreur dans les probabilités prédites
par rapport aux données. Par exemple, si les données correspondent
à la classe primaire, nous obtenons une probabilité de 1.
Les mathématiques qui sous-tendent le maximum de vraisemblance
n'entrent pas dans le cadre de cet ouvrage. Il suffit néanmoins de
dire que les algorithmes de minimisation sont utilisés pour optimiser
les meilleures valeurs du coefficient pour les données
d'apprentissage.
Faire des prédictions avec la régression logistique
Il suffit d'entrer les chiffres dans l'équation et de calculer le résultat.
Voici un exemple pour clarifier les choses.
Supposons que nous ayons un modèle qui utilise la taille pour
prédire si une personne est un homme ou une femme - nous
utiliserons une taille de base de 150 cm.
Les coefficients ont été appris - b0 = -100 et b1 = 1,6. En utilisant
l'équation ci-dessus, on calcule la probabilité d'avoir un homme
d'une taille de 150 cm. Plus formellement, cela donnerait
P(homme|taille=150)
EXP() est utilisé pour e :
y = e^(b0 + b1*X) / (1 + e^(b0 + b1*X))
y = exp(-100 + 0,6*150) / (1 + EXP(-100 + 0,6*X))
y = 0.0000453978687
La probabilité qu'une personne soit de sexe masculin est donc
proche de zéro.
Dans la pratique, les probabilités peuvent être utilisées directement.
Toutefois, nous souhaitons obtenir une réponse solide à ce problème
de classification, de sorte que les probabilités peuvent être
converties en valeurs de classe binaires, c'est-à-dire que les
probabilités peuvent être converties en valeurs de classe binaires.
0 si p(homme) < 0,5
1 si p(homme) >= 0,5
L'étape suivante consiste à préparer les données.
Préparer les données pour la régression logistique
La régression logistique émet des hypothèses sur la distribution des
données et les relations qui sont similaires à celles de la régression
linéaire. La définition de ces hypothèses a fait l'objet d'un travail
considérable et elles sont rédigées dans un langage statistique et
probabiliste précis. Mon conseil ? Utilisez-les comme des règles
empiriques ou des lignes directrices, et n'ayez pas peur
d'expérimenter avec des schémas de préparation.
Voici un exemple de régression logistique en code Python :
Nous utiliserons pour cela le jeu de données Pima Indian Diabetes,
que vous pouvez télécharger ici. Tout d'abord, nous chargeons les
données à l'aide de la fonction read CSV de Pandas :
#import pandas
import pandas as pd
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi',
'pedigree', 'age', 'label']
# charger l'ensemble des données
pima = pd.read_csv("pima-indians-diabetes.csv",
header=None, names=col_names)
pima.head()
Ensuite, nous voulons sélectionner les caractéristiques. Les colonnes
peuvent être divisées en deux : la variable dépendante (la cible) et
les variables indépendantes (les caractéristiques).
#split dataset in features and target variable
feature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose',
'bp', 'pedigree']
X = pima[feature_cols] # Caractéristiques
y = pima.label # Variable cible
L'ensemble de données doit être divisé en un ensemble de données
de formation et un ensemble de données de test. Nous le faisons
avec la fonction train_test_split, en passant trois paramètres -
features, target, test_set_size. Vous pouvez également utiliser
random_state pour choisir les enregistrements de manière aléatoire :
# diviser X et y en ensembles de formation et de test
from sklearn.cross_validation import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0
.25,random_state=0)
 /home/admin/.local/lib/python3.5/site-
packages/sklearn/cross_validation.py:41 :
DeprecationWarning : Ce module a été déprécié dans la
version 0.18 en faveur du module model_selection dans
lequel toutes les classes et fonctions refactorisées sont
déplacées. Notez également que l'interface des nouveaux
itérateurs CV est différente de celle de ce module. Ce
module sera supprimé dans la version 0.20.
"Ce module sera supprimé dans la version 0.20.",
DeprecationWarning)
Nous avons utilisé un ratio de 75:25 pour diviser l'ensemble de
données - 75 % de données de formation et 25 % de données de
test.
Élaborer le modèle et faire la prédiction
Tout d'abord, importez le modèle de régression logistique et utilisez
la fonction LogisticRegression() pour créer un objet classificateur.
Vous pouvez ensuite ajuster le modèle à l'aide de fit() sur l'ensemble
d'apprentissage et utiliser predict() sur l'ensemble de test pour
effectuer les prédictions :
# importer la classe
from sklearn.linear_model import LogisticRegression

# instanciation du modèle (en utilisant les paramètres par

défaut)
logreg = LogisticRegression()

# ajuster le modèle aux données

logreg.fit(X_train,y_train)

#
 y_pred=logreg.predict(X_test)
Utilisation de la matrice de confusion pour évaluer le modèle
Une matrice de confusion est un tableau que nous utilisons lorsque
nous voulons évaluer les performances de notre modèle de
classification. Vous pouvez également l'utiliser pour visualiser les
performances d'un algorithme. Une matrice de confusion présente
la somme, par classe, des prédictions correctes et incorrectes :
# Importation de la classe de métrologie
from sklearn import metrics
cnf_matrix = metrics.confusion_matrix(y_test, y_pred)
matrice_cnf
array([[119, 11],
[ 26, 36]])
Le résultat est une matrice de confusion sous forme de tableau. La
dimension de la matrice est de 2*2 car il s'agit d'une classification
binaire. Les prédictions exactes sont représentées par les valeurs
diagonales, tandis que les valeurs non diagonales représentent les
prédictions inexactes. Dans ce cas, les résultats sont 119 et 36 pour
les prédictions réelles et 26 et 11 pour les prédictions inexactes.
Utilisation d'une carte thermique pour visualiser la matrice
de confusion
Il utilise Seaborn et Matplotlib pour visualiser les résultats dans la
matrice de confusion - nous utiliserons Heatmap :
# importer les modules nécessaires
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
 %matplotlib inline
class_names=[0,1] # nom des classes
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# créer une carte thermique
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True,
cmap="YlGnBu" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Matrice de confusion', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Étiquette prédite')
Texte(0.5,257.44,'Étiquette prédite')
Mesures d'évaluation
Nous pouvons maintenant évaluer le modèle à l'aide des mesures de
précision, de rappel et d'exactitude :
print("Précision :",metrics.accuracy_score(y_test, y_pred))
print("Précision :",metrics.precision_score(y_test, y_pred))
print("Recall :",metrics.recall_score(y_test, y_pred))
Le résultat est le suivant :
Précision : 0,8072916666666666
Précision : 0,7659574468085106
 Rappel : 0.5806451612903226
Nous avons obtenu une précision de classification de 80 %, ce qui
est considéré comme assez bon.
La métrique de précision concerne la précision, comme on peut s'y
attendre. Lorsque votre modèle fait des prédictions, vous voulez
savoir à quelle fréquence il fait la bonne. Dans notre cas, le modèle
a prédit avec une précision de 76 % que les personnes étaient
atteintes de diabète.
En termes de rappel, le modèle peut identifier correctement les
personnes atteintes de diabète dans l'ensemble de test dans 58 %
des cas.
Courbe ROC
La courbe ROC (Receiver Operating Characteristic curve) représente
le taux de vrais positifs par rapport au taux de faux positifs et
montre le compromis entre la spécificité et la sensibilité.
y_pred_proba = logreg.predict_proba(X_test)[: :,1]
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)
auc = metrics.roc_auc_score(y_test, y_pred_proba)
plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
plt.legend(loc=4)
plt.show()
Le score AUC est de 0,86. Un score de 0,5 indique un classificateur
médiocre, tandis qu'un score de 1 indique un classificateur parfait.
La valeur de 0,86 est la plus proche de la perfection.
L'objectif ultime de la modélisation prédictive est de faire des
prédictions aussi précises que possible, plutôt que d'analyser les
résultats. À ce titre, certaines hypothèses peuvent être
abandonnées, à condition que vous disposiez d'un modèle solide et
performant :
Variable de sortie binaire : vous pourriez penser que
cela est évident, étant donné que nous l'avons
mentionné précédemment. La régression logistique est
conçue pour la classification binaire, et elle prédit les
probabilités d'appartenance des instances à la première
classe ou à la classe par défaut et les fait basculer dans
une classification 0 ou 1.

Élimination du bruit : l'une des hypothèses est que la

variable de sortie, y, ne comporte pas d'erreur. Dès le
départ, vous devez supprimer les données aberrantes et
les données potentiellement mal classées de vos données
d'apprentissage.
Distribution gaussienne : comme la régression
logistique est linéaire mais que la sortie est transformée
de manière non linéaire, on suppose qu'il existe une
relation linéaire entre les variables d'entrée et de sortie.
Vous obtenez un modèle plus précis lorsque vous
transformez les variables d'entrée pour mieux mettre en
évidence la relation. Par exemple, les transformations
univariées, telles que Box-cox, log et root, permettent
d'obtenir ce résultat.
Suppression des entrées corrélées : de la même
manière que pour la régression linéaire, votre modèle
peut finir par être surajusté si vous avez trop d'entrées
fortement corrélées. Pensez à supprimer les entrées
fortement corrélées et à calculer les corrélations par
paire.
Échec de la convergence : il peut arriver que
l'estimation de la vraisemblance qui apprend les
coefficients ne converge pas. Cela peut être dû à un trop
grand nombre d'entrées fortement corrélées dans les
données ou à des données éparses, ce qui signifie que
les données d'entrée contiennent de nombreux zéros.
Algorithme d'apprentissage automatique de l'arbre
de décision
L'arbre de décision est un algorithme populaire, sans aucun doute
l'un des plus populaires, et il relève de l'apprentissage supervisé. Il
est utilisé avec succès avec des variables de sortie catégorielles et
continues.
Pour vous montrer comment fonctionne l'algorithme de l'arbre de
décision, nous allons en implémenter un dans la base de données de
l'UCI, Balance Scale Weight & Distance. La base de données contient
625 instances - 49 équilibrées et 288 à gauche et à droite. Il y a
quatre attributs numériques et le nom de la classe.
Paquets Python
Vous avez besoin de trois paquets Python pour cela :

Sklearn - un package ML populaire contenant de

nombreux algorithmes, et nous utiliserons certains
modules populaires, tels que train_test_split,
accuracy_score, et DecisionTreeClassifier.
NumPy - module numérique contenant des fonctions
mathématiques utiles, NumPy est utilisé pour manipuler
des données et lire des données dans des tableaux
NumPy.
Pandas - couramment utilisé pour lire/écrire des fichiers
et utilise des DataFrames pour manipuler des données.
Sklearn est l'endroit où se trouvent tous les paquets qui nous aident
à mettre en œuvre l'algorithme, et il est installé avec les commandes
suivantes :
en utilisant pip :
pip install -U scikit-learn
Avant de vous lancer, assurez-vous que NumPy et Scipy sont
installés et que pip l'est également. Si pip n'est pas installé, utilisez
les commandes suivantes pour l'obtenir :
python get-pip.py
Si vous utilisez conda, utilisez cette commande :
conda install scikit-learn
Hypothèses de l'arbre de décision
Les hypothèses suivantes ont été retenues pour cet algorithme :

L'ensemble de la formation est considéré comme la

racine au début du processus.
On suppose que les attributs sont catégoriques pour le
gain d'information et continus pour l'indice de Gini.
Les enregistrements sont distribués de manière
récursive, sur la base des valeurs des attributs.
Des méthodes statistiques sont utilisées pour classer les
attributs en tant que nœud interne ou racine.
Pseudocode :

Le meilleur attribut doit être trouvé et placé sur le nœud

racine de l'arbre
L'ensemble de données de formation doit être divisé en
sous-ensembles, en veillant à ce que chacun ait la même
valeur d'attribut.
Les nœuds feuilles doivent être trouvés dans chaque
branche en répétant les étapes 1 et 2 sur chaque sous-
ensemble.
La mise en œuvre de l'algorithme nécessite les deux phases
suivantes :

La phase de construction - l'ensemble de données est

prétraité, puis sklearn est utilisé pour diviser l'ensemble
de données en ensembles de test et de formation avant
de former le classificateur.
 La phase opérationnelle - des prédictions sont faites
et leur précision est calculée.
Importation des données
L'importation et la manipulation des données se font à l'aide du
paquet Pandas. L'URL que nous utilisons récupère l'ensemble des
données directement sur le site web de l'UCI, de sorte que vous
n'avez pas besoin de le télécharger au départ. Cela signifie que vous
aurez besoin d'une bonne connexion internet lorsque vous
exécuterez le code. Comme "," est utilisé pour séparer l'ensemble de
données, nous devons le passer en tant que paramètre de valeur
sep. Enfin, comme il n'y a pas d'en-tête dans l'ensemble de données,
le paramètre Header's doit être passé comme none. Si aucun
paramètre d'en-tête n'est passé, la première ligne de l'ensemble de
données sera utilisée comme en-tête.
Découper les données
Avant d'entraîner notre modèle, l'ensemble de données doit être
divisé en deux : l'ensemble d'entraînement et l'ensemble de test.
Pour ce faire, le module train_test_split de sklearn est utilisé. Tout
d'abord, la variable cible doit être séparée des attributs de
l'ensemble de données :
X = balance_data.values[ :, 1:5]
Y = balance_data.values[ :,0]
Ces deux lignes de code sépareront l'ensemble de données. X et Y
sont tous deux des variables - X stocke les attributs et Y stocke la
variable cible de l'ensemble de données. Ensuite, nous devons
diviser l'ensemble de données en ensembles de formation et de test
:
X_train, X_test, y_train, y_test = train_test_split(
X, Y, test_size = 0.3, random_state = 100)
Ces lignes de code divisent l'ensemble de données dans un rapport
de 70:30 - 70 % pour la formation et 30 % pour le test. La valeur du
paramètre test_size est fixée à 0,3. La variable appelée
random_state est un générateur de nombres pseudo-aléatoires
généralement utilisé dans les cas d'échantillonnage aléatoire.
Terminologie du code :
Les méthodes du gain d'information et de l'indice de Gini permettent
de sélectionner le bon attribut à placer au niveau du nœud interne
ou du nœud racine.
Indice de Gini :

Il s'agit d'une mesure utilisée pour évaluer la fréquence à

laquelle des éléments choisis au hasard seraient
identifiés de manière erronée.
Les attributs présentant un indice de Gini plus faible sont
privilégiés.
Sklearn prend en charge le critère "gini" et prend la
valeur "gini" par défaut.
Entropie :

Il s'agit d'une mesure de l'incertitude d'une variable

aléatoire, caractérisant l'impureté d'une collection
d'exemples arbitraires.
Plus l'entropie est élevée, plus elle contient
d'informations.
Gain d'information :

En règle générale, l'entropie change lorsqu'un nœud est

utilisé pour diviser les instances de formation d'un arbre
de décision en ensembles plus petits. Le gain
d'information est une mesure du changement.
Sklearn prend en charge le critère "entropie" du gain
d'information. Si nous avons besoin de la méthode
 Information Gain de Sklearn, il faut le mentionner
explicitement.
Score de précision :

Il est utilisé pour calculer le score de précision du

classificateur formé.
Matrice de confusion :

Elle permet de comprendre comment le classificateur

formé se comporte sur l'ensemble de données de test ou
de valider l'ensemble de données.
Entrons dans le code :
# Exécutez ce programme sur votre ordinateur local python
#, à condition que vous ayez installé
# les bibliothèques nécessaires.

# Importation des paquets nécessaires

import numpy as np
import pandas as pd
from sklearn.metrics import confusion_matrix
from sklearn.cross_validation import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report

# Fonction d'importation de l'ensemble de données

def importdata() :
 balance_data = pd.read_csv(
'https://archive.ics.uci.edu/ml/machine-learning-'+
'databases/balance-scale/balance-scale.data',
sep= ',', header = None)

# Impression de la forme du jeu de données

print ("Longueur de l'ensemble de données : ",
len(balance_data))
print ("Forme du jeu de données : ", balance_data.shape)

# Impression des observations de l'ensemble de données

print ("Dataset : ",balance_data.head())
return balance_data

# Fonction pour diviser l'ensemble de données

def splitdataset(balance_data) :

# Séparation de la variable cible

X = balance_data.values[ :, 1:5]
Y = balance_data.values[ :, 0]

# Diviser l'ensemble de données en train et test

X_train, X_test, y_train, y_test = train_test_split(
X, Y, test_size = 0.3, random_state = 100)

return X, Y, X_train, X_test, y_train, y_test

# Fonction pour effectuer l'entraînement avec giniIndex.
def train_using_gini(X_train, X_test, y_train) :

# Création de l'objet classificateur

clf_gini = DecisionTreeClassifier(criterion = "gini",
random_state = 100,max_depth=3,
min_samples_leaf=5)

# Effectuer une formation

clf_gini.fit(X_train, y_train)
return clf_gini

# Fonction permettant d'effectuer l'entraînement avec

l'entropie.
def tarin_using_entropy(X_train, X_test, y_train) :

# Arbre de décision avec entropie

clf_entropy = DecisionTreeClassifier(
critère = "entropie", état_aléatoire = 100,
max_depth = 3, min_samples_leaf = 5)

# Formation en cours d'exécution

clf_entropy.fit(X_train, y_train)
return clf_entropy

# Fonction de prédiction
def prediction(X_test, clf_object) :

# Prédiction sur le test avec giniIndex

y_pred = clf_object.predict(X_test)
print("Valeurs prédites :")
print(y_pred)
return y_pred

# Fonction de calcul de la précision

def cal_accuracy(y_test, y_pred) :

print("Matrice de confusion : ",

confusion_matrix(y_test, y_pred))

print ("Précision : ",

accuracy_score(y_test,y_pred)*100)

print("Rapport : ",
rapport_de_classification(y_test, y_pred))

# Code conducteur
def main() :

# Phase de construction
data = importdata()
X, Y, X_train, X_test, y_train, y_test = splitdataset(data)
clf_gini = train_using_gini(X_train, X_test, y_train)
 clf_entropie = tarin_utilisant_entropie(X_train, X_test,
y_train)

# Phase opérationnelle
print("Résultats avec l'indice de Gini :")

# Prédiction à l'aide de gini

y_pred_gini = prediction(X_test, clf_gini)
cal_accuracy(y_test, y_pred_gini)

print("Résultats avec l'entropie :")

# Prédiction à l'aide de l'entropie
y_pred_entropy = prediction(X_test, clf_entropy)
cal_accuracy(y_test, y_pred_entropy)

# Appel de la fonction principale

if __name__=="__main__" :
main()
Voici les informations sur les données :
Longueur de l'ensemble de données : 625
Forme de l'ensemble de données : (625, 5)
Ensemble de données : 01234
0B1111
1R1112
2R1113
 3R1114
4R1115
En utilisant l'indice de Gini, les résultats sont les suivants :
Valeurs prévues :
['R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L'
'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'L' 'L' 'L' 'L'
L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R'
'L' 'R'
R' 'L' 'R' 'R' 'L' 'L' 'R' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'L'
'R'
R' 'L' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'L' 'L'
"R" "R" "L" "L" "L" "R" "R" "L" "L" "L" "R" "L" "R" "R" "R" "R"
"R" "R" "R" "R
R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'L'
'L' 'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R'
'L' 'R'
'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'R'
'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'R'
L' 'R' 'R' 'L' 'L' 'R' 'R' 'R']
La matrice de confusion est la suivante
[[ 0 6 7]
[ 0 67 18]
[ 0 19 71]]
L'exactitude est de mise :
73.4042553191
Le rapport :
précision rappel f1-score soutien
B 0.00 0.00 0.00 13
L 0.73 0.79 0.76 85
R 0.74 0.79 0.76 90
avg/total 0,68 0,73 0,71 188
En utilisant l'Entropie, les résultats sont les suivants :
Valeurs prévues :
['R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L'
L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'L' 'L'
'L'
'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L' 'R'
'L' 'L'
R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L'
'R'
R' 'L' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'L' 'R'
'L'
"R" "R" "L" "L" "L" "R" "R" "L" "L" "L" "L" "R" "L" "R" "R" "R"
"R" "R" "R" "R
R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L'
'L' 'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R'
'L' 'R'
'L' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'R'
R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'L' 'R'
R' 'R' 'L' 'L' 'L' 'R' 'R' 'R']
La matrice de confusion est la suivante
[[ 0 6 7]
[ 0 63 22]
[ 0 20 70]]
La précision est
70.7446808511
Et le rapport est le suivant :
précision rappel f1-score soutien
B 0.00 0.00 0.00 13
L 0.71 0.74 0.72 85
R 0.71 0.78 0.74 90
moyenne / total 0,66 0,71 0,68 188
Algorithme d'apprentissage automatique Random
Forest
Le classificateur de forêt aléatoire est un autre algorithme
d'apprentissage automatique supervisé qui peut être utilisé pour la
régression, la classification et d'autres tâches liées aux arbres de
décision. La forêt aléatoire crée des ensembles d'arbres de décision
à partir de sous-ensembles de données de formation aléatoires. Elle
prend ensuite sa décision en utilisant les votes des arbres.
Pour démontrer comment cela fonctionne, nous utiliserons
l'ensemble de données bien connu des fleurs d'iris pour entraîner le
modèle et le tester. Le modèle sera construit pour déterminer les
classifications des fleurs.
Tout d'abord, nous chargeons l'ensemble de données :
# importation des bibliothèques nécessaires
# importation de la bibliothèque Scikit-learn et des
ensembles de données
from sklearn import datasets

# Chargement de l'ensemble de données sur les plantes iris

(classification)
iris = datasets.load_iris()
Code : vérification du contenu de notre jeu de données et
des noms des caractéristiques qu'il contient.
print(iris.target_names)
Sortie :
['setosa' 'versicolor' 'virginica']
Code :

print(iris.feature_names)
Sortie :
["longueur du sépale (cm)", "largeur du sépale (cm)",
"longueur du pétale (cm)", "largeur du pétale (cm)"].
Code :
# diviser les ensembles de données en deux parties, à savoir
les ensembles de données de formation et les ensembles de
données de test
X, y = datasets.load_iris( return_X_y = True)

# Diviser les tableaux ou les matrices en sous-ensembles

aléatoires de formation et de test
 from sklearn.model_selection import train_test_split
# c'est-à-dire 80 % d'ensembles de données de formation et
30 % d'ensembles de données de test
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size = 0.70)
Code : Importation des bibliothèques nécessaires et du
module de classification de la forêt aléatoire.
# Importation du classificateur de forêt aléatoire du module
assemble
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
# création d'un cadre de données de l'ensemble de données
IRIS
data = pd.DataFrame({'sepallength' : iris.data[ :, 0],
'sepalwidth' : iris.data[ :, 1],
petallength" : iris.data[ :, 2], "petalwidth" :
iris.data[ :, 3],
'species' : iris.target})
Code : Examiner un ensemble de données
# impression des 5 premiers ensembles de données dans
l'ensemble de données iris
print(data.head())
Le résultat est le suivant :
sepallength sepalwidth petallength petalwidth species

0 5.1 3.5 1.4 0.2 0

 1 4.9 3.0 1.4 0.2 0

2 4.7 3.2 1.3 0.2 0

3 4.6 3.1 1.5 0.2 0

4 5.0 3.6 1.4 0.2 0

Ensuite, nous créons le classificateur Random Forest, nous
l'entraînons et nous le testons :
# Création d'un classificateur RF
clf = RandomForestClassifier(n_estimateurs = 100)

# Entraînement du modèle sur l'ensemble des données

d'entraînement
# La fonction d'ajustement est utilisée pour former le
modèle en utilisant les ensembles d'entraînement comme
paramètres.
clf.fit(X_train, y_train)

# effectuer des prédictions sur l'ensemble de données de

test
y_pred = clf.predict(X_test)

# les métriques sont utilisées pour déterminer la précision

ou l'erreur
from sklearn import metrics
print()
 # utilisation du module métrique pour le calcul de la
précision
print("ACCURACY OF THE MODEL : ",
metrics.accuracy_score(y_test, y_pred))
Sortie :
PRÉCISION DU MODÈLE : 0,9238095238095239

Code : prédire le type de fleur à partir de l'ensemble des

données
# prédire de quel type de fleur il s'agit.
clf.predict([[3, 3, 2, 2]])
Et le résultat est le suivant :
array([0])
Le résultat nous indique que la classification de la fleur est le type
Setosa. Notez que l'ensemble de données contient trois types -
Setosa, Vericolor et Virginia.
Ensuite, nous voulons trouver les caractéristiques importantes dans
l'ensemble de données :
# Importation du classificateur de forêt aléatoire du module
assemble
from sklearn.ensemble import RandomForestClassifier
# Créer une forêt aléatoire de classification
clf = RandomForestClassifier(n_estimateurs = 100)
 # Entraîner le modèle à l'aide des ensembles d'entraînement
clf.fit(X_train, y_train)
Code : Calcul de l'importance des caractéristiques
# en utilisant la variable d'importance de la caractéristique
import pandas as pd
feature_imp = pd.Series(clf.feature_importances_, index =
iris.feature_names).sort_values(ascending = False)
feature_imp
Le résultat est le suivant :
largeur des pétales (cm) 0,458607
longueur des pétales (cm) 0,413859
longueur du sépale (cm) 0,103600
largeur du sépale (cm) 0,023933
dtype : float64
Chaque arbre de décision créé par l'algorithme de la forêt aléatoire
présente une variance élevée. Cependant, lorsqu'ils sont tous
combinés en parallèle, la variance est faible. Cela s'explique par le
fait que les arbres individuels sont parfaitement formés sur
l'échantillon de données spécifié et que le résultat ne dépend pas
d'un seul arbre, mais de tous. Dans les problèmes de classification,
un classificateur à vote majoritaire est utilisé pour obtenir le résultat
final. Dans les problèmes de régression, le résultat est le fruit d'une
agrégation - la moyenne de tous les résultats.
La forêt aléatoire utilise la technique d'agrégation et de bootstrap,
également appelée bagging. L'idée est de combiner plusieurs arbres
de décision pour déterminer le résultat plutôt que de se fier à
chacun d'entre eux.
La partie bootstrap de la technique est celle où l'échantillonnage
aléatoire des lignes et des caractéristiques forme les ensembles de
données d'échantillonnage pour chaque modèle. La technique de
régression doit être abordée comme n'importe quelle technique de
ML :

Une donnée ou une question spécifique est élaborée et

la source est obtenue pour déterminer les données dont
nous avons besoin.
Les données doivent être dans un format accessible ou
doivent être converties dans un format accessible.
Toutes les anomalies notables doivent être spécifiées,
ainsi que les points de données manquants qui
pourraient être nécessaires pour obtenir les bonnes
données.
Le modèle d'apprentissage automatique est créé, ainsi
qu'un ensemble de modèles de base que vous souhaitez
obtenir.
Le modèle d'apprentissage automatique est formé sur les
données
Les données d'essai sont utilisées pour tester le modèle
Les mesures de performance des données testées et
prédites sont comparées
Si le modèle ne donne pas les résultats escomptés, il
convient de l'améliorer, de modifier les données ou
d'utiliser une autre technique de modélisation.
À la fin, les données sont interprétées et rapportées.
Voici un autre exemple du fonctionnement de la forêt aléatoire.
Tout d'abord, les bibliothèques sont importées :
# Importation des bibliothèques
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
Ensuite, l'ensemble des données est importé et imprimé :
data = pd.read_csv('Salaries.csv')
print(data)
Ensuite, toutes les lignes et la colonne 1 sont sélectionnées dans
l'ensemble de données pour x et toutes les lignes et la colonne 2
pour y :
x = data.iloc[ :, 1:2].values
print(x)
y = data.iloc[ :, 2].values
L'agresseur de la forêt aléatoire est adapté à l'ensemble des données
:
# Ajustement de la régression Random Forest à l'ensemble
de données
# importer le régresseur
from sklearn.ensemble import RandomForestRegressor

# créer un objet régresseur

regressor = RandomForestRegressor(n_estimateurs = 100,
random_state = 0)

# ajuster le régresseur avec les données x et y

regressor.fit(x, y)
Le résultat est prévu :
Y_pred = regressor.predict(np.array([6.5]).reshape(1, 1)) #
tester la sortie en changeant les valeurs
Le résultat est visualisé :
# Visualisation des résultats de la régression Random Forest

# arange pour créer une plage de valeurs

# de la valeur minimale de x à la valeur maximale
# Valeur de x avec une différence de 0,01
# entre deux valeurs consécutives
X_grid = np.arange(min(x), max(x), 0.01)

# reshape pour remodeler les données en un tableau

len(X_grid)*1,
# i.e. pour créer une colonne à partir de la valeur X_grid
X_grid = X_grid.reshape((len(X_grid), 1))

# Diagramme de dispersion pour les données originales

plt.scatter(x, y, color = 'blue')

# tracer les données prédites

plt.plot(X_grid, regressor.predict(X_grid),
couleur = 'vert')
plt.title('Random Forest Regression')
plt.xlabel('Niveau de position')
plt.ylabel('Salaire')
plt.show()
Réseaux neuronaux artificiels Algorithme
d'apprentissage automatique
Les réseaux neuronaux artificiels (RNA) sont des paradigmes de
traitement de l'information basés sur le fonctionnement du cerveau
humain. Comme un être humain, un RNA apprend par l'exemple. Ils
sont configurés pour des applications particulières, comme la
classification des données ou la reconnaissance des formes, grâce à
un processus d'apprentissage qui consiste principalement à ajuster
les connexions entre les neurones.
Le cerveau humain est constitué de milliards et de milliards de
neurones reliés entre eux par des synapses. Ce sont les connexions
par lesquelles les neurones envoient des impulsions à d'autres
neurones. Lorsqu'un neurone envoie un signal à un autre, le signal
est ajouté aux entrées du neurone. Lorsqu'un certain seuil est
dépassé, le neurone cible envoie un signal. C'est à peu près ainsi
que se déroule le processus de réflexion interne.
En data science, ce processus est modélisé par des réseaux créés
sur ordinateur à l'aide de matrices. Nous pouvons comprendre ces
réseaux comme des abstractions de neurones sans aucune des
complexités biologiques. Nous pourrions devenir très complexes ici,
mais nous ne le ferons pas. Nous allons créer un réseau neuronal
simple à deux couches, capable de résoudre un problème de
classification linéaire
Supposons que nous voulions prédire la sortie, en utilisant des
entrées et des sorties spécifiées comme exemples d'apprentissage.
Le processus de formation est le suivant :

1. Propagation vers l'avant

Les entrées sont multipliées par les poids :
Soit Y = WiIi = W1I1+W2I2+W3I3
Le résultat passe par une formule sigmoïde afin que la sortie du
neurone puisse être calculée. Cette fonction normalise le résultat
pour qu'il soit compris entre 0 et 1.
1/1 + e-y

2. Propagation dorsale
L'erreur est calculée. Il s'agit de la différence entre le résultat réel et
le résultat escompté. En fonction de l'erreur, les poids peuvent être
ajustés. Pour ce faire, multipliez l'erreur par l'entrée, puis
recommencez avec le gradient de la courbe sigmoïde :
Poids += Erreur Entrée Sortie (1-Sortie) ,ici Sortie (1-Sortie) est la
dérivée de la courbe sigmoïde.
L'ensemble du processus doit être répété pour autant d'itérations
qu'il y en a, soit potentiellement des milliers.
Voyons à quoi ressemble l'ensemble codé en Python, en utilisant
NumPy pour effectuer les calculs de matrices. Assurez-vous que
NumPy est déjà installé et continuez avec le code suivant :
from joblib.numpy_pickle_utils import xrange
from numpy import *

classe NeuralNet(objet) :
def __init__(self) :
# Générer des nombres aléatoires
random.seed(1)

# Attribuer des poids aléatoires à une matrice 3 x 1,

self.synaptic_weights = 2 * random.random((3, 1)) - 1
 # La fonction Sigmoïde
def __sigmoïde(self, x) :
return 1 / (1 + exp(-x))

# La dérivée de la fonction sigmoïde.

# C'est le gradient de la courbe sigmoïde.
def __sigmoïde_dérivée(self, x) :
retour x * (1 - x)

# Former le réseau neuronal et ajuster les poids à chaque

fois.
def train(self, inputs, outputs, training_iterations) :
pour itération dans xrange(training_iterations) :
# Passez l'ensemble d'apprentissage dans le réseau.
output = self.learn(inputs)

# Calculer l'erreur
erreur = sorties - sortie

# Ajuster les poids par un facteur

factor = dot(inputs.T, error *
self.__sigmoïd_derivative(output))
self.synaptic_weights += factor

# Le réseau neuronal réfléchit.

def learn(self, inputs) :

 return self.__sigmoïde(dot(inputs,
self.synaptic_weights))

si __name__ == "__main__" :
# Initialisation
neural_network = NeuralNet()

# L'ensemble de formation.
inputs = array([[0, 1, 1], [1, 0, 0], [1, 0, 1]])
outputs = array([[1, 0, 1]]).T

# Former le réseau neuronal

neural_network.train(inputs, outputs, 10000)

# Tester le réseau neuronal avec un exemple de test.

print(neural_network.learn(array([1, 0, 1])))
La sortie
Après 10 itérations, le NN devrait prédire une valeur de 0,6598,921.
Ce n'est pas ce que nous voulons, car la réponse devrait être 1. Si le
nombre d'itérations est porté à 100, la sortie est de 0,87680541.
Cela signifie que le réseau s'améliore au fur et à mesure des
itérations. Ainsi, pour 10 000 itérations, nous nous rapprochons le
plus possible d'un résultat de 0,9897704.
Étapes de le machine learning
Si seulement le machine learning était aussi simple que
d'appliquer un algorithme aux données et d'obtenir des
prédictions. Malheureusement, ce n'est pas le cas, et cela
implique beaucoup plus d'étapes pour chaque projet que vous
réalisez :
Première étape - Recueillir les données
Il s'agit de la première et de la plus importante étape de le
machine learning, qui est de loin celle qui prend le plus de temps.
Elle consiste à collecter toutes les données nécessaires à la
résolution du problème, et en quantité suffisante. Par exemple,
supposons que nous voulions construire un modèle qui prédise les
prix de l'immobilier. Dans ce cas, nous avons besoin d'un
ensemble de données contenant des informations sur les ventes
précédentes, que nous pouvons utiliser pour former une structure
tabulaire. Nous résoudrons un problème similaire lorsque nous
vous montrerons plus tard comment mettre en œuvre un
problème de régression.
Deuxième étape - Préparation des données
Lorsque nous disposons des données, il faut les mettre dans le
bon format et les prétraiter. Le prétraitement comprend
différentes étapes, notamment le nettoyage des données. S'il y a
des valeurs anormales, telles que des chaînes de caractères au
lieu de nombres, ou des valeurs vides, vous devez savoir comment
les traiter. La méthode la plus simple consiste à supprimer les
lignes contenant des valeurs vides, bien qu'il existe d'autres
façons de procéder. Parfois, vous pouvez également avoir des
colonnes qui n'ont aucune incidence sur les résultats ; ces
colonnes peuvent également être supprimées. En général, la
visualisation des données permet de voir les données sous forme
de tableaux, de graphiques et de diagrammes. Une fois ces
données analysées, nous pouvons déterminer les caractéristiques
importantes.
Troisième étape - Choix du modèle
Les données sont maintenant prêtes et nous avons besoin d'un
algorithme d'apprentissage automatique pour les alimenter.
Certaines personnes utilisent indifféremment "algorithme
d'apprentissage automatique" et "modèle d'apprentissage
automatique", mais il ne s'agit pas de la même chose. Le modèle
est le résultat de l'algorithme. Lorsque l'algorithme est mis en
œuvre sur les données, nous obtenons un résultat contenant les
nombres, les règles et les autres structures de données liées à
l'algorithme et nécessaires pour faire les prédictions. Par exemple,
nous obtiendrons une équation montrant la ligne la mieux ajustée
si nous effectuons une régression linéaire sur les données. Cette
équation est le modèle. Si nous ne procédons pas à l'ajustement
des hyperparamètres, l'étape suivante consistera à entraîner le
modèle.
Étape 4 - Réglage des hyperparamètres
Les hyperparamètres sont essentiels car ils sont responsables du
contrôle du comportement d'un modèle d'apprentissage
automatique. L'objectif est de trouver la meilleure combinaison
d'hyperparamètres pour obtenir les meilleurs résultats. Mais quels
sont ces hyperparamètres ? Prenons l'exemple de l'algorithme K-
NN et de la variable K. Lorsque l'on donne différentes valeurs à K,
les résultats diffèrent de manière prévisible. La meilleure valeur
de K n'est pas définie, et chaque ensemble de données aura sa
propre valeur. Il n'existe pas non plus de moyen simple de
connaître les meilleures valeurs ; tout ce que l'on peut faire, c'est
essayer différentes valeurs et voir les résultats que l'on obtient.
Dans ce cas, K est un hyperparamètre et ses valeurs doivent être
ajustées pour obtenir les bons résultats.
Étape 5 - Évaluation du modèle
Ensuite, nous voulons savoir si le modèle a bien fonctionné. La
meilleure façon de le savoir est de le tester sur d'autres données.
Il s'agit des données de test, qui doivent être complètement
différentes des données sur lesquelles l'algorithme a été entraîné.
Lorsque vous entraînez un modèle, vous ne voulez pas qu'il
apprenne les valeurs des données d'entraînement. Vous voulez
plutôt qu'il apprenne le modèle sous-jacent des données et qu'il
l'utilise pour faire des prédictions sur des données inédites. Nous
reviendrons sur ce point dans la section suivante.
Sixième étape - Faire des prévisions
L'étape finale consiste à utiliser le modèle sur des problèmes réels
dans l'espoir qu'il fonctionne comme prévu.
Évaluation d'un modèle d'apprentissage automatique
La formation d'un modèle d'apprentissage automatique est une
étape importante de le machine learning. L'évaluation du
fonctionnement du modèle sur des données inédites est tout aussi
importante et doit être prise en compte pour chaque pipeline que
vous construisez. Vous devez savoir si votre modèle fonctionne et, le
cas échéant, si ses prédictions sont fiables ou non. Le modèle
mémorise-t-il les données que vous lui fournissez ou apprend-il par
l'exemple ? S'il ne fait que mémoriser des données, ses prédictions
sur des données inédites seront pratiquement inutiles.
Nous allons prendre le temps d'examiner quelques-unes des
techniques que vous pouvez utiliser pour évaluer votre modèle et
voir s'il fonctionne bien. Nous examinerons également quelques-
unes des mesures d'évaluation courantes pour les méthodes de
régression et de classification avec Python.
Techniques d'évaluation des modèles
Le traitement des performances de votre modèle d'apprentissage
automatique nécessite une évaluation, qui fait partie intégrante de
tout projet de data science dans lequel vous êtes impliqué. Lorsque
vous évaluez le modèle, vous cherchez à estimer le degré de
précision de la généralisation du modèle sur des données inédites.
Les méthodes d'évaluation des modèles se répartissent en deux
catégories distinctes : la validation croisée et la retenue. Toutes deux
utilisent des ensembles de test, qui sont des ensembles de données
entièrement nouveaux, jamais vus auparavant, pour évaluer les
performances. Comme vous le savez déjà, il n'est pas recommandé
d'utiliser les mêmes données que celles sur lesquelles vous avez
formé un modèle pour le tester, car le modèle n'apprendra rien - il se
contentera de mémoriser les données sur lesquelles vous l'avez
formé. Les prédictions seront toujours correctes, quel que soit
l'endroit où se trouve l'ensemble de données d'apprentissage. C'est
ce qu'on appelle l'overfitting.
Retenue
L'évaluation Holdout teste les modèles sur des données différentes
des données d'apprentissage, fournissant ainsi une estimation non
biaisée des performances d'apprentissage. L'ensemble de données
sera divisé en trois sous-ensembles aléatoires :

L'ensemble d'entraînement - il s'agit d'un sous-

ensemble de l'ensemble de données complet utilisé dans
la construction du modèle prédictif.
L'ensemble de validation - ce sous-ensemble de
l'ensemble de données est utilisé pour évaluer les
performances du modèle. Il nous fournit une plate-forme
de test qui nous permet d'affiner les paramètres de notre
modèle et de choisir le modèle le plus performant.
Sachez que vous n'aurez pas besoin d'un ensemble de
validation pour chaque algorithme.
L'ensemble de test - il s'agit des données non vues,
un sous-ensemble de l'ensemble de données primaire
utilisé pour nous indiquer comment le modèle peut
fonctionner à l'avenir. Si vous constatez que le modèle
s'adapte mieux à l'ensemble d'apprentissage qu'à
l'ensemble de test, vous êtes probablement en présence
d'un cas de surajustement.
La technique de la retenue est utile parce qu'elle est simple, flexible
et rapide. Cependant, elle s'accompagne d'une association à une
variance élevée. En effet, les différences entre les ensembles de
données de formation et d'essai peuvent entraîner des différences
significatives en termes d'estimation de la précision.
Validation croisée
La technique de validation croisée divise l'ensemble de données
primaire en deux : un ensemble d'entraînement pour former le
modèle et un autre ensemble indépendant pour évaluer l'analyse. La
technique de validation croisée la plus connue est sans doute la
technique k-fold, qui divise l'ensemble de données primaires en un
nombre k de sous-échantillons de taille égale. Chaque sous-
échantillon est appelé "pli", et le nombre k définit un nombre
spécifique - généralement, 5 ou 10 sont les options préférées. Ce
processus est répété un nombre k de fois et, à chaque fois, un sous-
ensemble k est utilisé pour la validation, tandis que les sous-
ensembles restants sont combinés en un ensemble d'apprentissage.
L'efficacité du modèle est déterminée à partir d'une estimation
moyenne de l'ensemble des k essais.
Par exemple, lorsque vous effectuez une validation croisée dix fois,
les données sont divisées en dix parties, de taille à peu près égale.
Les modèles sont ensuite formés dans l'ordre - le premier pli est
utilisé comme ensemble de test, tandis que les neuf autres sont
utilisés pour la formation. Cette opération est répétée pour chaque
partie, et la moyenne des dix essais est calculée pour déterminer
l'efficacité du modèle.
Chaque point de données est utilisé une fois comme ensemble de
test et fait partie de l'ensemble de formation k fois, dans notre cas,
neuf. Cela permet de réduire considérablement le biais, car presque
toutes les données sont utilisées pour l'ajustement. Elle réduit
également la variance de manière significative car presque toutes les
données sont utilisées dans l'ensemble de test. L'efficacité de cette
méthode est renforcée par le fait que les ensembles de test et
d'entraînement sont interchangés.
Mesures d'évaluation des modèles
La quantification des performances du modèle nécessite l'utilisation
de mesures d'évaluation, et celles que vous utilisez dépendent du
type de tâche que vous effectuez - régression, classification,
regroupement, etc. Certaines mesures sont adaptées à plusieurs
tâches, comme la précision-rappel. La classification, la régression et
les autres tâches d'apprentissage supervisé constituent le plus grand
nombre d'applications d'apprentissage automatique, c'est pourquoi
nous nous concentrerons sur la régression et la classification
Métriques de classification
Nous examinerons rapidement les mesures les plus courantes pour
les problèmes de classification, notamment :

Précision de la classification
Matrice de confusion
Perte logarithmique
AUC - Aire sous la courbe
Mesure F
Précision de la classification
Il s'agit de l'une des mesures les plus courantes en matière de
classification, qui indique les prédictions correctes par rapport à
l'ensemble des prédictions. Le module sklearn est utilisé pour
calculer la précision de la classification, comme dans l'exemple ci-
dessous :
#import modules
importation d'avertissements
import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn import datasets
from sklearn.metrics import accuracy_score
#Ignorer les avertissements
warnings.filterwarnings('ignore')
# Chargement de l'ensemble de données sur les chiffres
iris = datasets.load_iris()
# # Créer une matrice de caractéristiques
X = iris.data
# Créer un vecteur cible
y = iris.target
#Taille de l'essai
taille_du_test = 0,33
#générer le même ensemble de nombres aléatoires
graine = 7
#Paramètres de validation croisée
kfold = model_selection.KFold(n_splits=10,
random_state=seed)
#Instance du modèle
modèle = Régression logistique()
#Évaluer la performance du modèle
notation = "précision
 results = model_selection.cross_val_score(model, X, y,
cv=kfold, scoring=scoring)
print('Accuracy -val set : %.2f%% (%.2f)' %
(results.mean()*100, results.std()))

#split data
X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
#Modèle d'ajustement
model.fit(X_train, y_train)
#Précision sur l'ensemble de test
result = model.score(X_test, y_test)
print("Précision - ensemble de test : %.2f%%" %
(result*100.0))
Dans ce cas, la précision est de 88 %.
La validation croisée nous permet de tester le modèle pendant la
formation, en vérifiant qu'il n'y a pas de surajustement et en
cherchant à voir comment le modèle se généralisera sur les données
de test. La validation croisée permet également de comparer les
performances de différents modèles sur le même ensemble de
données et nous aide à choisir les meilleures valeurs de paramètres
pour garantir la plus grande précision possible du modèle. C'est ce
que l'on appelle l'ajustement des paramètres.
Matrice de confusion
Les matrices de confusion fournissent plus de détails sur la
répartition des bonnes et des mauvaises classifications pour chaque
classe individuelle. Dans le cas présent, nous utiliserons l'ensemble
de données Iris pour la classification et le calcul de la matrice de
confusion :
#import modules
importation d'avertissements
import pandas as pd
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
%matplotlib inline

#Ignorer les avertissements

warnings.filterwarnings('ignore')
# Chargement de l'ensemble de données sur les chiffres
url = "http://archive.ics.uci.edu/ml/machine-learning-
databases/iris/iris.data"
df = pd.read_csv(url)
# df = df.values
X = df.iloc[ :,0:4]
y = df.iloc[ :,4]
# print (y.unique())
#Taille de l'essai
taille_du_test = 0,33
#générer le même ensemble de nombres aléatoires
graine = 7
#Séparer les données en un ensemble de formation et un
ensemble de test.
X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
#Modèle de formation
modèle = Régression logistique()
model.fit(X_train, y_train)
pred = model.predict(X_test)

#Construire la matrice de confusion

labels = ['Iris-setosa', 'Iris-versicolor', 'Iris-virginica']
cm = confusion_matrix(y_test, pred, labels)
print(cm)
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(cm)
plt.title('Matrice de confusion du classificateur')
fig.colorbar(cax)
ax.set_xticklabels([''] + labels)
ax.set_yticklabels([''] + labels)
plt.xlabel('Prédit')
plt.ylabel('True')
plt.show()
Pour expliquer brièvement comment une matrice de confusion doit
être interprétée, il suffit de dire ceci :
Les éléments de la diagonale représentent le nombre de points pour
lesquels l'étiquette prédite et l'étiquette réelle sont égales. Tout ce
qui ne se trouve pas sur la diagonale a été mal étiqueté. Plus les
valeurs de la diagonale sont élevées, mieux c'est, car cela indique un
plus grand nombre de prédictions correctes.
Notre classificateur a correctement prédit les 13 plants d'iris Setosa
et les 18 plants d'iris Virginica dans les données de test, mais il s'est
trompé en classant quatre plants Versicolor comme Virginica.
Perte logarithmique
La perte logarithmique, également appelée perte logarithmique, est
utilisée pour mesurer les performances d'un modèle de classification
lorsqu'une valeur de probabilité comprise entre 0 et 1 est utilisée
comme entrée de prédiction. En cas de divergence entre la
probabilité prédite et l'étiquette réelle, nous avons constaté une
augmentation de la perte logarithmique. Cette valeur doit être
minimisée par le modèle d'apprentissage automatique - plus la perte
logarithmique est faible, mieux c'est, et les meilleurs modèles ont
une perte logarithmique de 0.
#Classification LogLoss
importation d'avertissements
import pandas
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss

warnings.filterwarnings('ignore')
 url =
"https://raw.githubusercontent.com/jbrownlee/Datasets/mas
ter/pima-indians-diabetes.data.csv"
dataframe = pandas.read_csv(url)
dat = dataframe.values
X = dat[ :,:-1]
y = dat[ :,-1]
graine = 7
#split data
X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
model.fit(X_train, y_train)
#prédire et calculer la perte logarithmique
pred = model.predict(X_test)
accuracy = log_loss(y_test, pred)
print("Perte logarithmique : %.2f" % (précision))
Surface sous la courbe (SSC)
Cette mesure de performance évalue la capacité des classificateurs
binaires à faire la distinction entre les classes positives et les classes
négatives :
#Classification Aire sous la courbe
importation d'avertissements
import pandas
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, roc_curve

warnings.filterwarnings('ignore')

url =
"https://raw.githubusercontent.com/jbrownlee/Datasets/mas
ter/pima-indians-diabetes.data.csv"
dataframe = pandas.read_csv(url)
dat = dataframe.values
X = dat[ :,:-1]
y = dat[ :,-1]
graine = 7
#split data
X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
model.fit(X_train, y_train)

# prédire les probabilités

probs = model.predict_proba(X_test)
# conserver les probabilités pour l'issue positive uniquement
probs = probs[ :, 1]

auc = roc_auc_score(y_test, probs)

print('AUC - Test Set : %.2f%%' % (auc*100))
 # calculer la courbe roc
fpr, tpr, thresholds = roc_curve(y_test, probs)
# plot no skill
plt.plot([0, 1], [0, 1], linestyle='--')
# tracer la courbe roc pour le modèle
plt.plot(fpr, tpr, marker='.')
# afficher le graphique
plt.show()
Dans cet exemple, nous avons une AUC supérieure à 0,5 et proche
de 1. Le classificateur parfait a une courbe ROC le long de l'axe des
y puis le long de l'axe des x.
Mesure F
Également appelé score F, il mesure la précision d'un test, en
utilisant le rappel et la précision du test pour obtenir le score. La
précision indique les résultats positifs corrects divisés par le nombre
total d'observations positives prédites. Le rappel indique les résultats
positifs corrects divisés par le total des observations positives réelles
ou le total de tous les échantillons pertinents :
importation d'avertissements
import pandas
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss
from sklearn.metrics import precision_recall_fscore_support
as score, precision_score, recall_score, f1_score

warnings.filterwarnings('ignore')
url =
"https://raw.githubusercontent.com/jbrownlee/Datasets/mas
ter/pima-indians-diabetes.data.csv"
dataframe = pandas.read_csv(url)
dat = dataframe.values
X = dat[ :,:-1]
y = dat[ :,-1]
taille_du_test = 0,33
graine = 7

modèle = Régression logistique()

#split data
X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
model.fit(X_train, y_train)
precision = precision_score(y_test, pred)
print('Précision : %f' % précision)
# rappel : tp / (tp + fn)
recall = recall_score(y_test, pred)
print('Rappel : %f' % rappel)
# f1 : tp / (tp + fp + fn)
f1 = f1_score(y_test, pred)
print('Score F1 : %f' % f1)
Métriques de régression
Deux mesures principales sont utilisées pour évaluer les problèmes
de régression : l'erreur quadratique moyenne et l'erreur absolue
moyenne.
L'erreur absolue moyenne, également appelée MAE, indique la
somme des différences absolues entre les valeurs réelles et les
valeurs prédites. L'erreur quadratique moyenne, également appelée
RMSE, mesure une moyenne de l'ampleur de l'erreur en "prenant la
racine carrée de la moyenne des différences quadratiques entre la
prédiction et l'observation réelle".
Voici comment nous mettons en œuvre ces deux mesures :
import pandas
from sklearn import model_selection
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error,
mean_squared_error
from math import sqrt
url =
"https://raw.githubusercontent.com/jbrownlee/Datasets/mas
ter/housing.data"
dataframe = pandas.read_csv(url, delim_whitespace=True)
df = dataframe.values
X = df[ :,:-1]
y = df[ :,-1]
graine = 7
modèle = Régression linéaire()
#split data
 X_train, X_test, y_train, y_test =
model_selection.train_test_split(X, y, test_size=test_size,
random_state=seed)
model.fit(X_train, y_train)
#predict
pred = model.predict(X_test)
print("MAE test score :", mean_absolute_error(y_test, pred))
print("RMSE test score :", sqrt(mean_squared_error(y_test,
pred)))
Dans un monde idéal, la performance estimée d'un modèle nous dira
si le modèle est performant ou non sur des données inédites. La
plupart du temps, nous construisons des modèles pour prédire des
données futures et, avant de choisir une mesure, vous devez
comprendre le contexte - chaque modèle utilisera des ensembles de
données différents et des objectifs différents pour résoudre le
problème.
Implémentation d'algorithmes d'apprentissage
automatique avec Python
À ce stade, vous devriez déjà disposer de tous les logiciels et
bibliothèques dont vous avez besoin sur votre machine. Nous
utiliserons principalement Scikit-learn pour résoudre deux
problèmes : la régression et la classification.
Mise en œuvre d'un problème de régression
Nous voulons résoudre le problème de la prévision des prix des
logements en fonction de caractéristiques spécifiques, telles que
la taille du logement, le nombre de pièces, etc.

Collecte des données - nous n'avons pas besoin de

collecter manuellement les données requises, car
quelqu'un l'a déjà fait pour nous. Tout ce que nous
 avons à faire, c'est d'importer cet ensemble de
données. Il convient de noter que tous les ensembles
de données disponibles ne sont pas gratuits, mais ceux
que nous utilisons le sont.
Nous voulons l'ensemble de données Boston Housing, qui contient
des enregistrements décrivant des banlieues ou des villes de
Boston. Les données proviennent de la SMSA (Standard
Metropolitan Statistical Area) de Boston en 1970, et les attributs
ont été définis comme suit :

1.
CRIM : le taux de criminalité par habitant
dans chaque ville
2.
ZN : la proportion de terrains résidentiels
zonés pour des lots de plus de 25 000 pieds carrés.
3.
INDUS : la proportion d'hectares de
commerces autres que de détail dans chaque ville
4.
CHAS : la variable muette Charles River (=
1 si la parcelle est bordée par la rivière ; 0 si elle ne
l'est pas)
5.
NOX : concentrations d'oxyde nitrique en
parties par 10 millions
6.
RM : le nombre moyen de pièces dans
chaque propriété
7.
AGE : proportion de logements occupés par
leur propriétaire et construits avant 1940
 8.
DIS : les distances pondérées par rapport
aux cinq centres d'emploi de Boston
9.
RAD : l'indice d'accessibilité aux autoroutes
radiales
10.
TAXE : taux de l'impôt foncier sur la valeur
totale par tranche de 10 000 dollars.
11.
PTRATIO : le taux d'encadrement par ville
12.
B : 1000(Bk-0.63)2 où Bk est la proportion de
Noirs dans chaque ville
13.
LSTAT : % du statut inférieur de la population
14.
MEDV : Valeur médiane des logements
occupés par leur propriétaire, en milliers de dollars
Vous pouvez télécharger l'ensemble des données ici.
Téléchargez le fichier et ouvrez-le pour voir les données sur les
ventes de maisons. Notez que l'ensemble de données n'est pas
présenté sous forme de tableau et que les colonnes n'ont pas de
nom. Les virgules séparent toutes les valeurs.
La première étape consiste à placer les données sous forme de
tableau, ce que Pandas va nous aider à faire. Nous donnons à
Pandas une liste avec tous les noms de colonnes et un délimiteur
de "\s+", ce qui signifie que chaque entrée peut être différenciée
lorsque des espaces simples ou multiples sont rencontrés.
Nous commencerons par importer les bibliothèques dont nous
avons besoin, puis le jeu de données au format CSV. Le tout est
importé dans un DataFrame Pandas.
import numpy as np
import pandas as pd
column_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX',
'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT',
'MEDV']
bos1 = pd.read_csv('housing.csv', delimiter=r"\s+",
names=column_names)

Prétraitement des données

Ensuite, les données doivent être prétraitées. Lorsque nous
examinons l'ensemble de données, nous constatons immédiatement
qu'il ne contient pas de valeurs NaN. Nous constatons également
que les données sont des nombres et non des chaînes de caractères,
de sorte que nous n'avons pas à nous préoccuper des erreurs lors de
l'entraînement du modèle.
Nous diviserons les données en deux : 70 % pour la formation et 30
% pour le test.
bos1.isna().sum()

from sklearn.model_selection import train_test_split

X=np.array(bos1.iloc[ :,0:13])
Y=np.array(bos1["MEDV"])
#La taille des données de test est de 30% des données
totales.
x_train, x_test, y_train, y_test =train_test_split(X,Y, test_size
= 0.30, random_state =5)
 Choisissez votre modèle
Pour résoudre ce problème, nous voulons deux algorithmes
d'apprentissage supervisé pour résoudre la régression. Les
résultats de ces deux algorithmes seront ensuite comparés. Le
premier est le K-NN et le second est la régression linéaire, tous
deux ayant fait l'objet d'une démonstration plus tôt dans cette
partie.
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
#charger notre premier modèle
lr = LinearRegression()
#entraîner le modèle sur les données d'entraînement
lr.fit(x_train,y_train)
#prédire les données de test afin de pouvoir évaluer le
modèle ultérieurement
pred_lr = lr.predict(x_test)
#charger le deuxième modèle
Nn=KVoisinsRegresseurs(3)
Nn.fit(x_train,y_train)
pred_Nn = Nn.predict(x_test)

Ajuster les hyperparamètres

Tout ce que nous allons faire ici est d'ajuster la valeur K dans le K-
NN - nous pourrions faire plus, mais c'est juste pour commencer,
donc je ne veux pas que vous soyez trop submergés. Nous
utiliserons une boucle for et vérifierons les résultats de k, de 1 à
50. Le K-NN fonctionne rapidement sur de petits ensembles de
données, donc cela ne prendra pas trop de temps.
 import sklearn
for i in range(1,50) :
model=KNeighborsRegressor(i)
model.fit(x_train,y_train)
pred_y = model.predict(x_test)
mse = sklearn.metrics.mean_squared_error(y_test,
pred_y,squared=False)
print("{} erreur pour k = {}".format(mse,i))
Le résultat sera une liste d'erreurs pour k = 1 jusqu'à k = 50.
L'erreur la plus faible est pour k = 3, ce qui justifie l'utilisation de
k = 3 lors de l'apprentissage du modèle.

Évaluer le modèle
Nous utiliserons la méthode MSE (mean_squared_error) de Scikit-
learn pour évaluer notre modèle. Le paramètre 'squared' doit être
défini comme False, sinon vous n'obtiendrez pas l'erreur RMSE :
#Erreur de régression linéaire
mse_lr= sklearn.metrics.mean_squared_error(y_test,
pred_lr,squared=False)
print("error for Linear Regression = {}".format(mse_lr))
#Erreur de régression linéaire
mse_Nn= sklearn.metrics.mean_squared_error(y_test,
pred_Nn,squared=False)
print("error for K-NN = {}".format(mse_Nn))
Le résultat est le suivant :
erreur pour la régression linéaire = 4.627293724648145
erreur pour K-NN = 6.173717334583693
Nous pouvons en conclure que la régression linéaire est bien
meilleure que le K-NN sur cet ensemble de données. Ce ne sera pas
toujours le cas, car cela dépend des données avec lesquelles vous
travaillez.

Faire la prédiction
Enfin, nous pouvons prédire les prix des logements à l'aide de nos
modèles et de la fonction predict. Veillez à obtenir toutes les
caractéristiques présentes dans les données que vous avez utilisées
pour former le modèle.
Voici le programme complet, du début à la fin :
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
column_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM',
'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']
bos1 = pd.read_csv('housing.csv', delimiter=r"\s+",
names=column_names)
X=np.array(bos1.iloc[ :,0:13])
Y=np.array(bos1["MEDV"])
#La taille des données de test est de 30% des données
totales.
x_train, x_test, y_train, y_test =train_test_split(X,Y, test_size
= 0.30, random_state =54)
#charger notre premier modèle
lr = LinearRegression()
 #entraîner le modèle sur les données d'entraînement
lr.fit(x_train,y_train)
#prédire les données de test afin de pouvoir évaluer le
modèle ultérieurement
pred_lr = lr.predict(x_test)
#charger le deuxième modèle
Nn=KVoisinsRegresseurs(12)
Nn.fit(x_train,y_train)
pred_Nn = Nn.predict(x_test)
#Erreur de régression linéaire
mse_lr= sklearn.metrics.mean_squared_error(y_test,
pred_lr,squared=False)
print("error for Linear Regression = {}".format(mse_lr))
#Erreur de régression linéaire
mse_Nn= sklearn.metrics.mean_squared_error(y_test,
pred_Nn,squared=False)
print("error for K-NN = {}".format(mse_Nn))
Mise en œuvre d'un problème de classification
Le problème que nous résolvons ici est celui de la classification de
la population Iris. L'ensemble de données Iris est l'un des plus
populaires et des plus courants pour les débutants. Il contient 50
échantillons de chacune des trois espèces d'iris, ainsi que d'autres
propriétés des fleurs. L'une d'entre elles est linéairement
séparable de deux espèces, mais ces deux espèces ne sont pas
linéairement séparables l'une de l'autre. Cet ensemble de données
comporte les colonnes suivantes :
Différentes espèces d'iris
 Longueur du sépaleCm

Largeur du sceptreCm

Longueur du pétaleCm

Largeur du pétaleCm

Espèces
Ce jeu de données est déjà inclus dans Scikit-learn, il suffit donc
de l'importer :
from sklearn.datasets import load_iris
iris = load_iris()
X=iris.data
Y=iris.target
print(X)
print(Y)
La sortie est une liste de caractéristiques avec quatre éléments -
ce sont les caractéristiques. La partie inférieure est une liste
d'étiquettes, toutes transformées en nombres car le modèle est
incapable de comprendre les chaînes de caractères - chaque nom
doit être codé sous la forme d'un nombre.
Voici le texte complet :
from sklearn.model_selection import train_test_split
#La taille des données de test est de 30 % des données
totales.
 x_train, x_test, y_train, y_test =train_test_split(X,Y,
test_size = 0.3, random_state =5)
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
#fitting our model to train and test
Nn = KNeighborsClassifier(8)
Nn.fit(x_train,y_train)
#la méthode score() calcule la précision du modèle.
print("Accuracy for K-NN is ",Nn.score(x_test,y_test))
Lr = Régression logistique()
Lr.fit(x_train,y_train)
print("La précision de la régression logistique est de
",Lr.score(x_test,y_test))
Le résultat est le suivant :
La précision du K-NN est de 1,0
La précision de la régression logistique est de 0,9777777777777777
Avantages et inconvénients de le machine learning
Tout a ses avantages et ses inconvénients, et le machine learning
n'échappe pas à la règle :
Avantages

Facilite l'identification des tendances et des

modèles dans les données
Le machine learning permet d'examiner d'énormes quantités de
données, à la recherche de tendances et de modèles que l'œil
humain ne verrait pas. Par exemple, Flipkart, Amazon et d'autres
sites de commerce électronique utilisent le machine learning pour
comprendre comment leurs clients naviguent et ce qu'ils achètent
afin de leur envoyer des offres pertinentes, des détails sur les
produits et des rappels. Les résultats de le machine learning sont
utilisés pour montrer des publicités pertinentes à chaque client en
fonction de son historique de navigation et d'achat.

Amélioration continue
De nouvelles données sont générées en permanence, et le fait de
fournir de nouvelles données aux modèles d'apprentissage
automatique leur permet de se perfectionner au fil du temps, de
devenir plus précis et d'améliorer continuellement leurs
performances. Cela permet de prendre des décisions toujours
meilleures.

Ils peuvent traiter des données multi-

variétés et multi-dimensionnelles.
Les algorithmes d'apprentissage automatique peuvent traiter
facilement des données multivariées et multidimensionnelles dans
des environnements incertains ou dynamiques.

Ils sont largement utilisés

Quel que soit votre secteur d'activité, le machine learning peut
vous être utile. Où qu'il soit appliqué, il peut donner aux
entreprises les moyens et les réponses dont elles ont besoin pour
prendre de meilleures décisions et offrir à leurs clients une
expérience utilisateur plus personnelle.
Inconvénients

Elle nécessite d'énormes quantités de

données
Les modèles d'apprentissage automatique ont besoin de grandes
quantités de données pour apprendre, mais la quantité de jours
n'est qu'une petite partie. Il doit s'agir de données de haute
qualité, non biaisées, et en quantité suffisante. Parfois, il est
même nécessaire d'attendre que de nouvelles données soient
générées avant de pouvoir entraîner le modèle.

Il faut du temps et des ressources

Le machine learning nécessite suffisamment de temps pour que
les algorithmes apprennent et se développent afin de s'assurer
qu'ils peuvent faire leur travail avec un niveau significatif de
pertinence et de précision. Il nécessite également un niveau élevé
de ressources, ce qui peut impliquer l'utilisation d'une puissance
informatique supérieure à celle dont vous disposez.

Interprétation des résultats

Un autre défi consiste à être capable d'interpréter avec précision
les résultats fournis par les algorithmes. Vous devez également
choisir soigneusement les algorithmes en fonction de la tâche à
accomplir et de ce qu'ils sont censés faire. Vous ne choisirez pas
toujours le bon algorithme du premier coup, même si votre
analyse vous oriente vers un algorithme spécifique.

Susceptible d'erreurs
Bien que le machine learning soit autonome, il est très sensible
aux erreurs. Supposons que vous entraîniez un algorithme avec
des ensembles de données si petits qu'ils ne sont pas inclusifs. Il
en résulterait des prédictions biaisées, car votre ensemble
d'apprentissage est biaisé. Une entreprise pourrait ainsi présenter
à ses clients des publicités ou des choix d'achat non pertinents.
Avec le machine learning, ce type de problème peut déclencher
toute une liste d'erreurs qui peuvent ne pas être détectées
pendant un certain temps et, lorsqu'elles le sont enfin, il faut
beaucoup de temps pour trouver l'origine du problème et y
remédier.
Conclusion
Merci d'avoir pris le temps de lire mon guide. La data science est l'un
des mots à la mode les plus utilisés actuellement, et cela ne
changera pas. Avec la quantité de données générées chaque jour,
les entreprises s'appuient sur la data science pour faire progresser
leur activité, interagir intelligemment avec leurs clients et s'assurer
qu'elles leur fournissent exactement ce dont ils ont besoin, au
moment où ils en ont besoin.
Le machine learning est un autre mot à la mode, un sous-ensemble
de la data science qui n'est devenu populaire qu'au cours des deux
dernières décennies. Le machine learning consiste à apprendre aux
machines à penser comme des humains, à prendre des décisions
comme le ferait un humain et, bien que la véritable pensée humaine
soit encore loin d'exister pour les machines, elle s'améliore de jour
en jour.
Nous avons abordé plusieurs techniques de data science et
algorithmes d'apprentissage automatique qui peuvent vous aider à
travailler avec des données et à en tirer des informations utiles.
Cependant, nous n'avons fait qu'effleurer la surface, et il y a encore
beaucoup à apprendre. Utilisez ce livre comme point de départ et,
une fois que vous aurez maîtrisé ce qu'il contient, vous pourrez aller
plus loin dans votre apprentissage. La data science et le machine
learning sont deux des emplois les plus convoités dans le monde
aujourd'hui et, avec l'augmentation des données, il y aura de plus en
plus de postes à pourvoir. Il est logique d'apprendre quelque chose
qui peut potentiellement vous mener à une carrière lucrative et très
satisfaisante.
Je vous remercie encore une fois d'avoir choisi mon guide et je vous
souhaite bonne chance dans votre parcours en data science.
Références
"A Comprehensive Guide to Python Data Visualization with Matplotlib and Seaborn". Built
In, builtin.com/data-science/data-visualization-tutorial.
"Guide des algorithmes d'apprentissage automatique et de leurs applications". Sas.com,
2019, www.sas.com/en_gb/insights/articles/analytics/machine-learning-algorithms.html.
Analytics Vidhya. "Scikit-Learn in Python - Important Machine Learning Tool". Analytics
Vidhya, 5 janvier 2015, www.analyticsvidhya.com/blog/2015/01/scikit-learn-python-
machine-learning-tool/.
"Différence entre la data science et le machine learning : Tout ce qu'il faut savoir en 2021".
Jigsaw Academy, 9 avril 2021, www.jigsawacademy.com/what-is-the-difference-between-
data-science-and-machine-learning/.
Leong, Nicholas. "Python for Data Science - a Guide to Pandas". Medium, 11 juin 2020,
towardsdatascience.com/python-for-data-science-basics-of-pandas-5f8d9680617e.
"Les algorithmes d'apprentissage automatique avec Python". Data Science | Machine
Learning | Python | C++ | Coding | Programming | JavaScript, 27 Nov. 2020,
thecleverprogrammer.com/2020/11/27/machine-learning-algorithms-with-python/.
Mujtaba, Hussain. "Tutoriel d'apprentissage automatique pour les débutants - Apprentissage
automatique avec Python. GreatLearning, 18 septembre 2020,
www.mygreatlearning.com/blog/machine-learning-tutorial/.
Mutuvi, Steve. "Introduction à l'évaluation des modèles d'apprentissage automatique".
Medium, Heartbeat, 16 avr. 2019, heartbeat.fritz.ai/introduction-to-machine-learning-model-
evaluation-fa859e1b2d7f.
Python, Real. "Pandas for Data Science (Learning Path) - Real Python". Realpython.com,
realpython.com/learning-paths/pandas-data-science/.
"The Ultimate NumPy Tutorial for Data Science Beginners (Le tutoriel NumPy ultime pour les
débutants en data science). Analytics Vidhya, 27 avril 2020,
www.analyticsvidhya.com/blog/2020/04/the-ultimate-numpy-tutorial-for-data-science-
beginners/.