CLEANING DATA IN R

Course Description
Il est communément admis que les data scientists passent 80 % de leur temps à
nettoyer et à manipuler des données et seulement 20 % de leur temps à les
analyser. Le temps passé à nettoyer est vital car l'analyse de données sales peut
vous amener à tirer des conclusions inexactes.

Dans ce cours, vous apprendrez à nettoyer les données sales. En utilisant R, vous
apprendrez à identifier les valeurs qui ne semblent pas correctes et à corriger les
données modifiées en convertissant les types de données, en remplissant les
valeurs manquantes et en utilisant la correspondance de chaîne floue. Au fur et à
mesure de votre apprentissage, vous perfectionnerez vos compétences en
travaillant avec des ensembles de données du monde réel, y compris des trajets
en vélo en libre-service, des portefeuilles d'actifs clients et des critiques de
restaurants, en développant les compétences dont vous avez besoin pour passer
de données brutes à des informations impressionnantes aussi rapidement et le
plus précisément possible !

1- Problèmes de données courants

Dans ce chapitre, vous apprendrez comment résoudre certains des problèmes de
données sales les plus courants. Vous allez convertir les types de données,
appliquer des contraintes de plage pour supprimer les futurs points de données et
supprimer les points de données en double pour éviter le double comptage.

Contraintes de type de données

1. Contraintes de type de données
Salut et bienvenue au cours. Je m'appelle Maggie et je vais vous guider pendant
que vous apprenez à nettoyer les données dans R.

2. Plan du cours
Dans ce cours, vous apprendrez à diagnostiquer et à localiser différents
problèmes dans vos données et comment ils peuvent survenir au cours de votre
flux de travail.

3. Plan du cours
Vous découvrirez également ce qui peut mal se passer si vos données ne sont
pas correctement nettoyées,

4. Plan du cours
et comment traiter différents types de données sales.

5. Plan du cours
Dans ce chapitre, nous aborderons les problèmes les plus courants que vous
pourriez rencontrer et comment les résoudre. Commençons!

6. Pourquoi avons-nous besoin de données propres ?

Pour comprendre pourquoi nous avons besoin de données propres, examinons le
workflow de la science des données. Dans un flux de travail typique de la
science des données, nous accédons généralement d'abord aux données brutes,
les explorons et les traitons, puis développons des informations. Enfin, nous
rapportons ces informations.

7. Pourquoi avons-nous besoin de données propres ?

Des données sales peuvent apparaître avant même que nous y accédions, en
raison d'erreurs telles que des fautes de frappe et des fautes d'orthographe.

8. Pourquoi avons-nous besoin de données propres ?

Si nous ne corrigeons pas ces erreurs dès le début, elles nous suivront tout au
long de notre flux de travail, ce qui signifie que nous pourrions finir par tirer des
conclusions incorrectes.
9. Contraintes de type de données
Vous avez probablement déjà rencontré différents types de données, tels que du
texte, des nombres, des catégories et des dates. Chacun de ces types de données
est traité différemment, donc si chaque variable n'est pas le bon type de données,
nous risquons de compromettre notre analyse.

10. Aperçu des types de données

Regardons un exemple. Voici un bloc de données contenant les revenus générés
et la quantité d'articles vendus pour différentes commandes client. Pour regarder
les types de données de chaque colonne dans "ventes", nous pouvons charger le
package dplyr et utiliser aperçu. Cela nous donne le type de données pour
chaque colonne. L'ID de commande et la quantité ont le type de données "dbl"
ou double, ce qui est la même chose que numérique - le double est juste un
moyen de spécifier le nombre de décimales que le nombre peut avoir.
Cependant, la colonne des revenus a le caractère de type de données, alors qu'il
devrait être numérique.

11. Vérification des types de données

Nous pouvons utiliser la fonction is-dot-numeric sur la colonne des revenus et
voir qu'elle n'est pas numérique. Une autre façon d'effectuer cette vérification
consiste à utiliser la fonction assert_is_numeric du package assertive. Cela
fournit une protection supplémentaire car cela générera une erreur et arrêtera
l'exécution de notre script, nous saurons donc immédiatement que quelque chose
ne va pas. Si nous appelons assert_is_numeric sur quelque chose qui est
numérique, rien n'est renvoyé.

12. Vérification des types de données

Tous les types de données ont une fonction is-dot qui renvoie VRAI ou FAUX
et une fonction assert-is qui ne renvoie rien ou une erreur.

13. Pourquoi le type de données est-il important ?

Nous pouvons utiliser la fonction de classe sur la colonne des revenus pour voir
qu'il s'agit d'un type de caractère. Si nous voulons savoir quel est le revenu
moyen, nous obtenons un NA et un avertissement, car prendre la moyenne du
texte n'a pas beaucoup de sens. C'est pourquoi il est important de vérifier que
nos types de données correspondent à ce que nous attendons. Sinon, nous
pourrions penser que nous obtenons une chose, dans ce cas une moyenne, alors
que nous obtenons en fait quelque chose de complètement différent, qui est un
NA. Nous devrons convertir cette colonne en un type numérique afin d'obtenir la
moyenne.

14. Problèmes de virgule

Les revenus d'impression indiquent une virgule dans chaque numéro. Nous
devrons les supprimer avant de convertir les chaînes en nombres.

15. Caractère à nombre

Cela peut être fait en utilisant str_remove du package stringr. Le premier
argument est la chaîne que nous voulons supprimer, qui est la colonne des
revenus. Le deuxième argument est ce que nous voulons supprimer, la virgule.
Si nous regardons revenue_trimmed, toutes les virgules ont disparu ! Pour
convertir revenue_trimmed en un type numérique, nous le passons en as-dot-
numeric.

16. Assembler
Nous pouvons tout rassembler dans le cadre de données de vente en appelant
mutate. Nous créons une nouvelle colonne appelée revenue_usd en utilisant
str_remove et as-dot-numeric.

17. Même fonction, résultats différents

Maintenant, en prenant la moyenne de revenue_usd nous donne le revenu
moyen, au lieu du NA que nous avons obtenu plus tôt.

18. Conversion des types de données

Tout comme les fonctions is-dot et assert-is, il existe des fonctions as-dot pour
convertir en n'importe quel type de données.
19. Attention : factoriser en numérique
Soyez prudent lorsque vous convertissez un facteur en un nombre. Les facteurs
sont un type de données qui représentent un ensemble limité de catégories
possibles. Ici, nous avons un vecteur product_type, qui est un facteur. 1000
représente les vêtements, 2000 représente la nourriture et 3000 représente
l'électronique. Si nous appelons as-numeric sur product_type, nous obtenons ces
nombres, ce qui n'est pas ce que nous recherchons. Cela est dû à la façon dont
les facteurs sont codés dans R. Au lieu de cela, nous devons d'abord utiliser des
caractères, puis des nombres.

20. Entraînons-nous !
Il est temps d'utiliser vos nouvelles connaissances sur les types de données !

Types de données courants

Étant donné que différents types de données sont traités et agissent
différemment, il est important de pouvoir identifier le type de données le plus
adapté aux données avec lesquelles vous travaillez. Dans cet exercice, vous
apprendrez à faire correspondre différentes données avec le type de données qui
facilite le traitement des données et l'extraction d'informations.
Instructions
Associez les éléments à leur type de données correspondant.

Conversion des types de données

Tout au long de ce chapitre, vous utiliserez des données de vélo en libre-service
à San Francisco appelées bike_share_rides. Il contient des informations sur les
stations de départ et d'arrivée de chaque trajet, la durée du trajet et certaines
informations sur l'utilisateur.

Avant de commencer à analyser un ensemble de données, il est important de

jeter un œil aux différents types de colonnes avec lesquels vous allez travailler,
ce que vous pouvez faire à l'aide de glimpse().
Dans cet exercice, vous allez examiner les types de données contenus dans
bike_share_rideset voir comment un type de données incorrect peut fausser
votre analyse.

Dplyr et assertives ont chargés et bike_share_rides disponibles.

Instructions 1
Examinez les types de données des colonnes de bike_share_rides.
Obtenez un résumé de la user_birth_yearcolonne de bike_share_rides.
Instructions 2
Question
Les statistiques récapitulatives de user_birth_year ne semblent pas offrir
beaucoup d'informations utiles sur les différentes années de naissance dans notre
ensemble de données. Pourquoi pensez-vous que c'est ?

Des réponses possibles

La user_birth_yearcolonne représente des regroupements de données et doit être
convertie en un fichier factor.
Instructions 3
Ajoutez une nouvelle colonne à bike_share_rides appelée user_birth_year_fct,
qui contient user_birth_year, convertie en facteur.
Affirmez que le user_birth_year_fctest un facteur pour confirmer la conversion.
Dextérité de type de données Dapper! En regardant les nouvelles statistiques
récapitulatives, plus de coureurs sont nés 1988que toute autre année.

Couper les cordes

Dans l'exercice précédent, vous avez pu identifier le type de données correct et
effectuer la conversion user_birth_yearvers le type correct, ce qui vous a permis
d'extraire des décomptes qui vous ont donné un peu plus d'informations sur
l'ensemble de données.
Un autre problème courant de données sales est d'avoir des bits supplémentaires
comme des signes de pourcentage ou des points dans les nombres, les obligeant
à être lus comme characters. Afin de pouvoir analyser ces nombres, les bits
supplémentaires doivent être supprimés et les nombres doivent être convertis de
characteren numeric. Dans cet exercice, vous devrez convertir la
durationcolonne de characteren numeric, mais avant que cela ne se produise, le
mot "minutes"doit être supprimé de chaque valeur.

dplyr, assertive, et stringr sont chargés et bike_share_rides sont disponibles.

Instructions
Utilisez str_remove() pour supprimer "minutes"de la duration colonne de
bike_share_rides. Ajoutez ceci en tant que nouvelle colonne appelée
duration_trimmed.
Convertissez la duration_trimmed colonne en un type numérique et ajoutez-la en
tant que nouvelle colonne appelée duration_mins.
Jetez un œil à bike_share_rides et affirmez que la duration_mins colonne est
numeric.
Calculer la moyenne de duration_mins.
Bon travail! En supprimant les caractères et en convertissant en un type
numérique, vous avez pu déterminer que la durée moyenne du trajet est
d'environ 13 minutes - pas mal pour une ville comme San Francisco !

Contraintes de portée
1. Contraintes de portée
Maintenant que nous avons discuté des contraintes de type de données, parlons
d'un autre type de contrainte : les contraintes de plage.

2. Qu'est-ce qu'une valeur hors plage ?

De nombreuses variables ont une plage dans laquelle vous pouvez
raisonnablement vous attendre à ce que tous les points de données se trouvent.
Par exemple, le test d'entrée à l'université aux États-Unis est noté entre 400 et
1600, il ne devrait donc pas y avoir de scores inférieurs à 400 ou supérieurs à
1600. D'autres exemples sont le poids d'un colis, qui ne peut pas être négatif, ou
la fréquence cardiaque. , qui devrait se situer entre 60 et 100 battements par
minute chez la plupart des adultes. Puisque nous savons quelles sont ces plages
raisonnables, nous savons qu'il y a quelque chose qui cloche si nous voyons un
score SAT de 2000 ou un poids de -5 livres dans notre ensemble de données.

3. Trouver des valeurs hors limites

Disons que nous recevons des données contenant des notes de films. Les films
sont classés à l'aide d'un système à cinq étoiles, donc toutes les notes doivent se
situer entre 0 et 5.

4. Trouver des valeurs hors limites

Pour voir s'il y a des données qui sont clairement hors de portée, nous pouvons
créer un histogramme. Nous allons créer un vecteur appelé breaks, qui contient
la note minimale, puis 0, le bas de la plage attendue, puis 5, le haut de la plage
attendue, puis la note maximale. Nous allons créer un histogramme de
avg_rating à l'aide de geom_histogram, en définissant l'argument breaks sur le
vecteur de breaks que nous venons de créer. On se retrouve avec un
histogramme décomposé en 3 groupes : trop bas, en gamme et trop haut. Nous
pouvons facilement voir maintenant qu'il y a une valeur inférieure à 0 et deux
valeurs supérieures à 5 dans notre ensemble de données.

5. Trouver des valeurs hors limites

Nous pouvons également utiliser la fonction assert_all_are_in_closed_range, qui
prend une valeur inférieure et une valeur supérieure. Il donnera une erreur si
quelque chose tombe en dehors de la plage spécifiée.

6. Gestion des valeurs hors limites

Une fois que nous avons identifié qu'il y a des valeurs hors limites, comment les
traitons-nous ? Nous pourrions supprimer complètement ces points de données,
mais cela ne devrait être fait que lorsque seule une petite proportion des valeurs
sont hors limites, sinon nous augmenterions considérablement la quantité de
biais dans notre ensemble de données. Nous pourrions également traiter chaque
valeur hors plage comme manquante ou la remplacer par « NA ». Cela nous
permet d'utiliser différentes techniques d'imputation pour les données
manquantes, dont nous parlerons plus en détail plus tard dans le cours. Nous
pouvons également remplacer les valeurs hors plage par la limite de plage. Par
exemple, si nous savons que nos notes devraient se situer entre 0 et 5 et qu'il y a
une valeur de 6, nous pouvons remplacer le 6 par 5 pour qu'il soit dans la plage.
Enfin, nous pouvons remplacer les valeurs par un autre nombre en fonction de
notre connaissance de l'ensemble de données. Par example,

7. Supprimer des lignes

Pour supprimer les lignes hors plage, nous pouvons utiliser la fonction de filtre
pour obtenir toutes les lignes dont les valeurs tombent dans la plage. Dans ce
cas, nous voulons toutes les notes supérieures ou égales à 0 et inférieures ou
égales à 5, ce qui éliminera les lignes qui ont une note hors limites. Si nous
créons maintenant un histogramme de avg_rating, nous pouvons voir qu'il ne
reste plus de valeurs hors limites dans l'ensemble de données.

8. Traiter comme manquant

Pour traiter les valeurs comme manquantes, nous devrons remplacer toutes les
valeurs hors limites par NA. Nous pouvons le faire en utilisant la fonction de
remplacement, qui prend dans la colonne dans laquelle vous souhaitez remplacer
les valeurs, la condition qui doit être remplie pour qu'un remplacement se
produise et ce que le remplacement doit être. Ici, nous créons une nouvelle
colonne appelée rating_miss, remplaçant les valeurs de la colonne avg_rating
qui sont trop grandes par NA.

9. Remplacement des valeurs hors limites

Nous pouvons également utiliser la fonction de remplacement pour remplacer
les valeurs hors plage par la limite de plage. Ici, nous remplaçons toutes les
valeurs de avg_rating supérieures à 5 par 5.

10. Contraintes de plage de dates

Les dates peuvent également être hors limites. Un scénario courant est lorsque
les données contiennent des dates dans le futur. Dans nos données de films,
toutes les dates doivent être dans le passé, car il ne nous est pas possible d'avoir
une cote de film pour un film que personne n'a encore vu. Nous pouvons utiliser
la fonction assert_all_are_in_past du package assertive pour vérifier les dates
futures, et il semble que nous en ayons une. Nous pouvons examiner cette ligne
de plus près en filtrant pour date_recorded supérieur à la date d'aujourd'hui. Tout
comme les nombres, les dates peuvent être comparées à l'aide des opérateurs
supérieur à, inférieur à et égal à égal. La fonction aujourd'hui de lubridate
obtiendra la date actuelle.

11. Suppression des dates hors limites

Nous pouvons également supprimer les lignes avec des dates futures en utilisant
filter, mais cette fois, nous filtrons pour date_recorded inférieur ou égal à
aujourd'hui. Lorsque nous utilisons assert_all_are_in_past maintenant, rien n'est
renvoyé, nous savons donc que nos contraintes de plage ont été respectées.

12. Entraînons-nous !
Il est maintenant temps de vous entraîner à gérer vos données avec des plages.

Contraintes de durée de trajet

Les valeurs hors limites peuvent fausser une analyse, il est donc important de les
détecter dès le début. Dans cet exercice, vous examinerez la
duration_mincolonne de plus près. Les vélos ne sont pas autorisés à être tenus à
l'extérieur pendant plus de 24 heures , ou 1440 minutes à la fois, mais des
problèmes avec certains vélos ont entraîné un enregistrement inexact de l'heure à
laquelle ils ont été rendus.

Dans cet exercice, vous allez remplacer les données erronées par la limite de
plage (1440 minutes), cependant, vous pouvez tout aussi facilement remplacer
ces valeurs par NAs.

dplyr, assertive, et ggplot2 sont chargés et bike_share_rides sont disponibles.

Instructions 1
Créez un histogramme à trois cases de la duration_min colonne d'
bike_share_rides utilisation ggplot2 pour identifier s'il existe des données hors
plage.
Instructions 2
Remplacez les valeurs de duration_minqui sont supérieures à 1440 minutes (24
heures) par 1440. Ajoutez ceci à bike_share_rides une nouvelle colonne appelée
duration_min_const.
Affirmez que toutes les valeurs de duration_min_const sont comprises entre 0 et
1440.
Remplacement radical ! La méthode de remplacement des données erronées par
la limite de plage fonctionne bien, mais vous pouvez tout aussi bien remplacer
ces valeurs par NAs ou autre chose à la place.

Retour vers le futur

Quelque chose s'est mal passé et il semble que vous ayez des données avec des
dates futures, ce qui est bien en dehors de la plage de dates avec laquelle vous
vous attendiez à travailler. Pour résoudre ce problème, vous devrez supprimer
tous les trajets de l'ensemble de données qui ont un dateà l'avenir. Avant de
pouvoir le faire, la datecolonne doit être convertie de a characteren Date. Les
avoir en tant Datequ'objets permettra de déterminer plus facilement les manèges
du futur, car R permet de vérifier facilement si un Dateobjet est avant (<) ou
après ( >) un autre.
dplyret assertives ont chargés et bike_share_rides disponibles.
Instructions
Convertissez la datecolonne de bike_share_ridesde characterau Datetype de
données.
Affirmez que toutes les valeurs de la datecolonne se sont produites dans le passé
et non dans le futur.
Filtrez bike_share_rides pour obtenir uniquement les trajets du passé ou
d'aujourd'hui, et enregistrez-le sous le nom bike_share_rides_past.
Affirmez que le dates in bike_share_rides_past ne s'est produit que dans le
passé.
Contraintes d'unicité
1. Contraintes d'unicité
Parfois, nous pouvons avoir des données contenant des points de données
dupliqués causés par une erreur plus tôt dans le pipeline. Les données
dupliquées peuvent avoir de nombreux effets secondaires indésirables, mais les
contraintes d'unicité nous aident à trouver et à corriger ces points de données
dupliqués.

2. Qu'est-ce qu'un doublon ?

Un doublon est un point de données qui a les mêmes valeurs qu'une autre
donnée dans toutes les colonnes, ou dans la plupart des colonnes.

3. Pourquoi des doublons se produisent-ils ?

Les doublons peuvent résulter d'erreurs de saisie de données ou d'autres erreurs
humaines,

4. Pourquoi des doublons se produisent-ils ?

à partir de bugs ou d'erreurs de conception dans les pipelines de données,

5. Pourquoi des doublons se produisent-ils ?

mais ils résultent le plus souvent d'erreurs lors de la réunion de données
provenant de plusieurs sources.

6. Duplicata complet
Un doublon complet se produit lorsqu'il y a plusieurs lignes qui ont la même
valeur dans chaque colonne. Ici, les lignes 2 et 4 sont des doublons complets
l'une de l'autre, et les lignes 5 et 6 sont également des doublons complets l'une
de l'autre.

7. Trouver des doublons complets

Nous pouvons trouver des doublons complets en utilisant la fonction
"dupliquée" intégrée de R. Si nous passons notre trame de données, appelée
credit_scores, nous obtenons un vecteur logique, qui est VRAI pour chaque
ligne en double. Si nous prenons la somme de ce vecteur, nous obtenons le
nombre total de doublons dans l'ensemble de données, qui est de 2.

8. Trouver des doublons complets

Nous pouvons vérifier les lignes qui sont en double en utilisant la fonction
dupliquée à l'intérieur du filtre, comme ceci.

9. Suppression des doublons complets

Étant donné que les doublons complets sont des copies exactes les uns des
autres, nous pouvons les traiter en les supprimant simplement de l'ensemble de
données, en ne laissant qu'une seule copie. Cela peut être fait en utilisant la
fonction distincte de dplyr sur notre bloc de données. Si nous comptons
maintenant le nombre de doublons dans l'ensemble de données, nous obtenons 0.

10. Doublons partiels

Les doublons partiels sont des lignes de données qui contiennent en grande
partie les mêmes informations et font référence au même point de données, mais
certaines colonnes peuvent différer entre elles. Ici, les lignes 3 et 4 sont des
doublons partiels l'une de l'autre et les lignes 5 et 6 sont des doublons partiels
l'une de l'autre. Ils ont le même nom et la même adresse, mais des cotes de crédit
différentes. Cela peut se produire en raison d'erreurs de saisie de données ou
d'erreurs techniques. Dans cet exemple, certaines données d'il y a un an peuvent
avoir été mélangées avec les données de cette année.

11. Recherche de doublons partiels

Pour inclure des doublons partiels dans notre recherche, nous pouvons utiliser la
fonction de comptage de dplyr pour compter le nombre d'occurrences de chaque
paire de prénom et de nom, puis filtrer les paires qui se produisent plus d'une
fois. Cela nous donnera des points de données qui partagent le même nom, mais
peuvent différer en termes d'adresse ou de pointage de crédit.
12. Recherche de doublons partiels
Nous pouvons l'enregistrer en tant que bloc de données appelé dup_ids, puis
filtrer pour examiner toutes les lignes qui ont un doublon. Cela nous donne une
liste des doublons complets et des doublons partiels dans l'ensemble de données.

13. Gestion des doublons partiels : suppression

Une façon de gérer les doublons partiels est de

14. Gestion des doublons partiels : suppression

supprimer tous les doublons

15. Gestion des doublons partiels : suppression

et n'en garder qu'un seul.

16. Suppression des doublons partiels

Dans R, nous pouvons également utiliser la fonction distinct pour supprimer les
doublons partiels, mais cette fois, nous passons les noms de colonnes sur
lesquels les doublons doivent être mis en correspondance. Ici, c'est le prénom et
le nom. Nous définissons également l'argument dot-keep_all sur TRUE, ce qui
conservera toutes les colonnes de la trame de données au lieu de seulement
first_name et last_name.

17. Traitement des doublons partiels : synthèse

Une autre façon de gérer les doublons partiels consiste à les résumer à l'aide
d'une statistique récapitulative, comme la moyenne ou le max. Étant donné que
les cotes de crédit diffèrent dans notre exemple,

18. Traitement des doublons partiels : synthèse

nous pouvons prendre la cote de crédit moyenne pour chaque individu
19. Traitement des doublons partiels : synthèse
ne conserver qu'un exemplaire de chaque duplicata,

20. Traitement des doublons partiels : synthèse

et utilisez la moyenne comme valeur du pointage de crédit.

21. Traitement des doublons partiels : synthèse

22. Résumer les doublons partiels
Pour résumer les doublons partiels, nous regroupons par prénom et nom, puis
mutons, en ajoutant une colonne contenant le score de crédit moyen pour chaque
nom. Puisque nous avons regroupé avant de muter, la colonne mean_score
contient le score moyen de chaque personne.

23. Résumer les doublons partiels

Nous pouvons canaliser tout cela dans distinct, en utilisant le prénom et le nom
et en définissant dot-keep_all sur TRUE pour supprimer les doublons
supplémentaires. Nous pouvons également supprimer l'ancienne colonne
credit_score pour nettoyer les choses.

24. Entraînons-nous !
Il est temps de plonger dans des données dupliquées !

Duplicata complet
Vous avez été informé qu'une mise à jour a été apportée au pipeline de données
de partage de vélos pour le rendre plus efficace, mais que des doublons sont plus
susceptibles d'être générés en conséquence. Pour vous assurer que vous pouvez
continuer à utiliser les mêmes scripts pour exécuter vos analyses hebdomadaires
sur les statistiques de trajet, vous devez d'abord vous assurer que tous les
doublons dans l'ensemble de données sont supprimés.
Lorsque plusieurs lignes d'un bloc de données partagent les mêmes valeurs pour
toutes les colonnes, elles sont des doublons complets les unes des autres. La
suppression des doublons comme celle-ci est importante, car le fait d'avoir la
même valeur répétée plusieurs fois peut modifier les statistiques récapitulatives
comme la moyenne et la médiane. Chaque trajet, y compris le sien, ride_iddoit
être unique.

Dplyr est chargé et bike_share_rides disponible.

Instructions
Obtenez le nombre total de doublons complets au format bike_share_rides.
Supprimez tous les doublons complets bike_share_rides et enregistrez le
nouveau bloc de données sousbike_share_rides_unique.
Obtenez le nombre total de doublons complets dans le nouveau
bike_share_rides_unique bloc de données.
Suppression des doublons éblouissante ! La suppression des doublons complets
garantira que les statistiques récapitulatives ne sont pas altérées par des points de
données répétés.

Suppression des doublons partiels

Maintenant que vous avez identifié et supprimé les doublons complets, il est
temps de rechercher les doublons partiels. Les doublons partiels sont un peu plus
délicats à gérer que les doublons complets. Dans cet exercice, vous allez d'abord
identifier les doublons partiels, puis mettre en pratique la technique la plus
courante pour les gérer, qui consiste à supprimer tous les doublons partiels, en
ne conservant que le premier.

Dplyr est chargé et bike_share_rides disponible.

Instructions 1
Comptez le nombre d'occurrences de chacun ride_id.
Filtrez les ride_ids qui se produisent plusieurs fois.
Instructions 2
Supprimez les doublons complets et partiels en bike_share_rides fonction
ride_id uniquement, en conservant toutes les colonnes.
Stockez-le en tant que bike_share_rides_unique.
Instructions 3
Trouvez les ride_ids dupliqués dans bike_share_rides_unique.
Suppression partielle parfaite des doublons ! Il est important de prendre en
compte les données avec lesquelles vous travaillez avant de supprimer les
doublons partiels, car on s'attend parfois à ce qu'il y ait des doublons partiels
dans un ensemble de données, par exemple si le même client effectue plusieurs
achats.

Agrégation de doublons partiels

Une autre façon de gérer les doublons partiels consiste à calculer une statistique
récapitulative des valeurs qui diffèrent entre les doublons partiels, telles que la
moyenne, la médiane, le maximum ou le minimum. Cela peut s'avérer utile
lorsque vous n'êtes pas sûr de la manière dont vos données ont été collectées et
que vous souhaitez une moyenne, ou si, sur la base des connaissances du
domaine, vous préférez avoir une estimation trop élevée qu'une estimation trop
basse (ou vice versa).

Dplyr est chargé et bike_share_rides disponible.

Instructions
Grouper bike_share_rides par ride_id et date.
Ajoutez une colonne appelée duration_min_avg qui contient la durée moyenne
du trajet pour les lignes ride_id et date.
Supprimez les doublons en fonction de ride_id et date, en conservant toutes les
colonnes du bloc de données.
Retirez la duration_min colonne.
Super agrégation ! L'agrégation de doublons partiels vous permet de conserver
des informations sur tous les points de données au lieu de conserver des
informations sur un seul point de données.
 2- Données catégorielles et textuelles
Les données catégoriques et textuelles peuvent souvent être parmi les parties les
plus compliquées d'un ensemble de données en raison de leur nature non
structurée. Dans ce chapitre, vous apprendrez à corriger les incohérences
d'espaces et de majuscules dans les étiquettes de catégorie, à regrouper plusieurs
catégories en une seule et à reformater les chaînes pour plus de cohérence.

Vérification de l'adhésion
1. Vérification de l'adhésion
Beau travail sur le chapitre 1 ! Dans le chapitre 2, nous discuterons des
problèmes qui surviennent dans le texte et les données catégorielles.
Commençons!

2. Données catégorielles
Une variable est catégorique lorsqu'elle ne peut prendre que des valeurs d'un
ensemble de valeurs prédéfini. Les variables catégorielles représentent des
groupes distincts. Le statut matrimonial, la catégorie de revenu du ménage et la
taille du t-shirt sont tous des exemples de variables catégorielles. Comme nous
l'avons vu au chapitre 1, les catégories sont stockées en tant que facteurs dans R.

3. Facteurs
Sous le capot, les facteurs sont stockés sous forme de nombres, où un nombre
représente chaque catégorie. Chaque numéro a une étiquette correspondante
pour faciliter la lecture et la compréhension de la sortie par les humains. Par
exemple, le statut matrimonial comporte deux catégories. La catégorie 1 est
étiquetée comme célibataire et la catégorie 2 est étiquetée comme mariée.

4. Niveaux de facteurs
Les facteurs ont ce qu'on appelle des niveaux, qui sont toutes les différentes
valeurs possibles qu'un facteur peut contenir. Ici, nous voyons qu'il y a quatre
valeurs possibles que tshirt_size peut avoir : small, medium, large et extra-large.
5. Des valeurs qui n'appartiennent pas
Étant donné que les facteurs ont ces niveaux prédéfinis, ils ne peuvent pas avoir
de valeurs qui se situent en dehors de ces niveaux. Par exemple, si nous
demandons aux gens quelle taille de t-shirt ils veulent et que quelqu'un répond
par small-slash-medium, nous ne pourrons pas traiter cette commande car notre
fournisseur ne fait pas cette taille.

6. Comment en arrive-t-on à ces valeurs ?

Comment obtenons-nous des valeurs qui ne sont pas membres de l'ensemble
prédéfini de catégories ? De telles incohérences peuvent survenir en raison
d'erreurs de saisie de données lorsque les données sont saisies à l'aide de texte
libre au lieu d'un système à choix multiples, ainsi que d'erreurs d'analyse des
données.

7. Filtrage des jointures : un aperçu rapide

Rappelez-vous que les jointures de filtrage sont un type de jointure qui conserve
ou supprime les observations de la première table, mais n'ajoute aucune nouvelle
colonne. Le premier type de jointure filtrante est une semi-jointure, qui répond à
la question « Quelles observations de X se trouvent également dans Y ? »

8. Filtrage des jointures : un aperçu rapide

L'autre type est une anti-jointure, qui répond à la question « Quelles
observations de X ne sont pas dans Y ? » Nous pouvons utiliser ces jointures de
filtrage pour rechercher et supprimer des valeurs de variables catégorielles qui
n'appartiennent pas.

9. Exemple de groupe sanguin

Jetons un coup d'oeil à un exemple. Nous avons une base de données appelée
study_data, qui contient les données d'une étude sur les groupes sanguins des
bébés. study_data contient le nom, la date de naissance et le groupe sanguin de
chaque enfant. Nous avons également une base de données appelée blood_types
qui contient tous les types de sang possibles qu'un humain peut avoir.
10. Exemple de groupe sanguin
Remarquez le problème ici? Jennifer a un groupe sanguin Z positif, qui n'est pas
un vrai groupe sanguin. Heureusement, nous pouvons utiliser le cadre de
données blood_types comme vérité terrain pour résoudre ce problème.

11. Trouver des non-membres

Pour trouver des groupes sanguins invalides dans nos données d'étude, nous
voulons trouver tous les groupes sanguins dans study_data qui ne sont PAS dans
le bloc de données blood_types. Cela signifie que nous aurons besoin d'un anti-
jointure.

12. Anti-jointure
Nous pouvons utiliser la fonction anti_join de dplyr pour obtenir les lignes de
study_data avec un groupe sanguin ne figurant pas dans le bloc de données
blood_types.

13. Retrait des non-membres

Pour supprimer les groupes sanguins invalides de nos study_data, nous voulons
trouver toutes les lignes avec un groupe sanguin dans le cadre de données
officiel blood_types. Cela signifie que nous devrons utiliser une semi-jointure.

14. Semi-jointure
Nous pouvons utiliser la fonction semi-join de dplyr pour obtenir les lignes de
study_data qui ont un groupe sanguin contenu dans le cadre de données officiel
blood_types. Cela supprime les données avec le groupe sanguin Z-positif.

15. Entraînons-nous !
Il est temps de pratiquer la vérification de l'adhésion !
Membres seulement
Jusqu'à présent dans le cours, vous avez découvert un certain nombre de
problèmes différents que vous pouvez rencontrer lorsque vous avez des données
modifiées, notamment des contraintes de type de données, des contraintes de
plage, des contraintes d'unicité et des contraintes d'appartenance. Il est important
de pouvoir identifier correctement le type de problème auquel vous faites face
afin de pouvoir le traiter correctement. Dans cet exercice, vous vous entraînerez
à identifier ces problèmes en mappant des scénarios de données modifiées à leur
type de contrainte.
Instructions
Classez chaque scénario selon qu'il s'agit d'un problème de contrainte d'adhésion
ou d'un type de problème différent.
Il est important de pouvoir identifier les types d'erreurs dans vos données afin
que vous sachiez comment les corriger.

Pas un membre
Maintenant que vous vous êtes entraîné à identifier les problèmes de contraintes
d'appartenance, il est temps de résoudre ces problèmes dans un nouvel ensemble
de données. Tout au long de ce chapitre, vous utiliserez un ensemble de données
appelé sfo_survey, contenant les réponses à l'enquête des passagers prenant des
vols depuis l'aéroport international de San Francisco (SFO). Les participants ont
été interrogés sur la propreté de l'aéroport, les temps d'attente, la sécurité et leur
satisfaction globale.

Il y a eu quelques problèmes lors de la collecte des données qui ont entraîné des
incohérences dans l'ensemble de données. Dans cet exercice, vous allez
travailler avec la dest_sizecolonne, qui classe la taille de l'aéroport de
destination vers lequel les passagers volaient. Une trame de données appelée
dest_sizesest disponible et contient toutes les tailles de destination possibles.
Votre mission est de trouver des lignes avec des dest_sizes invalides et de les
supprimer du bloc de données.

dplyra été chargé et sfo_surveyet dest_sizessont disponibles.

Instructions 1
Comptez le nombre d'occurrences de chacun dest_sizedans sfo_survey.
Instructions 2
Question
Regardez de plus près votre sortie. Quelles dest_sizevaleurs semblent enfreindre
les contraintes d'appartenance ?
"huge", " Small ", "Large "Et " Hub".
Instructions 3
Utilisez le bon type de jointure de filtrage sur le sfo_survey bloc de données et
le dest_sizes bloc de données pour obtenir les lignes sfo_survey avec des
dest_size valeurs non valides .
Obtenez les id, airline, destination et dest_size colonnes.
Instructions 4
Utilisez la jointure de filtrage correcte sur sfo_surveyet dest_sizespour obtenir
les lignes sfo_surveyqui ont un fichier dest_size.
Comptez le nombre de fois que chacun dest_sizese produit pour vous assurer
qu'il ne reste aucune valeur invalide.
Les anti-jointures peuvent vous aider à identifier les lignes à l'origine des
problèmes, et les semi-jointures peuvent supprimer les lignes à l'origine des
problèmes. Dans la leçon suivante, vous découvrirez d'autres façons de gérer les
mauvaises valeurs afin de ne pas perdre de lignes de données.

1. Problèmes de données catégoriques

Maintenant que nous avons discuté des contraintes d'adhésion, nous allons
approfondir les données catégorielles et discuter d'autres moyens de traiter ces
valeurs embêtantes qui n'appartiennent pas en plus de les supprimer.

2. Problèmes de données catégoriques

Il existe deux types spécifiques de données catégorielles sales dont nous allons
discuter. Le premier est lorsqu'il y a incohérence au sein d'une catégorie. Par
exemple, « Lézard » avec un « L » majuscule et « lézard » avec un « L »
minuscule doivent être mappés à la même catégorie même si leur majuscule
diffère. L'autre type est lorsqu'il y a trop de catégories. Si nous n'avons qu'un
seul point de données avec « Pug », un seul point de données avec « Lab » et un
seul point de données avec « Boxer », ces catégories pourraient ne pas être si
utiles en elles-mêmes. Il sera plus facile de travailler avec nos données si nous
les réduisons toutes dans une seule catégorie, « Chien ».

3. Exemple : classification des animaux

Commençons par un exemple. Nous avons une base de données appelée
animaux qui contient différentes caractéristiques d'animaux et leur type, comme
les mammifères, les poissons ou les oiseaux.

4. Vérification des catégories

Nous pouvons explorer toutes les différentes catégories de types dans les
données en utilisant count. En un coup d'œil, nous pouvons voir s'il y a des
catégories qui nécessitent une correction. Dès le départ, nous pouvons voir qu'il
existe plusieurs catégories pour les mammifères, y compris « mammifère » avec
des espaces supplémentaires avant et après le mot, « MAMMIF » en majuscules
et « Mammifère » avec une lettre majuscule et un espace supplémentaire.

5. Incohérence de cas
Pour corriger l'incohérence de casse entre les différentes catégories de
mammifères, nous pouvons utiliser la fonction str_to_lower du package stringr.
En regardant la ligne 3, nous pouvons voir que le mammifère avec un M
majuscule a été converti en minuscules.

6. Incohérence de cas
Si nous comptons maintenant la catégorie type_lower, nous pouvons voir qu'il y
a neuf catégories au lieu de dix puisque les majuscules "MAMMAL" ont été
converties en minuscules "mammal".

7. Incohérence de cas
Nous pourrions également tout convertir en majuscules en utilisant la fonction
str_to_upper.

8. Incohérence des espaces blancs

Pour remédier à l'incohérence dans l'espace blanc autour du mot "mammifère",
nous pouvons utiliser la fonction stringr str_trim. Cela supprimera tout espace
blanc au début et à la fin de la chaîne, mais pas au milieu de la chaîne.
Maintenant, la catégorie de la ligne 3 correspond à la catégorie de la ligne 1.

9. Incohérence des espaces blancs

Si nous regardons maintenant les différentes catégories, il n'y a qu'une seule
catégorie de mammifères, donc tous les mammifères de l'ensemble de données
ont été mappés à la même catégorie.

10. Trop de catégories

Jetez un œil aux catégories que nous avons maintenant. Notez que la plupart de
notre ensemble de données est composé de mammifères et d'oiseaux. Il n'y a que
deux amphibiens, deux poissons, un insecte, un invertébré et un reptile. Cela fait
5 catégories supplémentaires pour seulement 7 points de données, et les
statistiques récapitulatives pour ces groupes ne seront pas très utiles car elles ne
contiennent qu'une ou deux observations.

11. Réduire les catégories

Nous pouvons résoudre ce problème en regroupant ces catégories dans une
nouvelle catégorie plus large appelée « autre ». Tout d'abord, nous allons créer
un vecteur appelé other_categories qui stocke les catégories que nous voulons
regrouper. Ensuite, nous allons charger le package forcats et ajouter une
nouvelle colonne au bloc de données des animaux appelée type_collapsed. Pour
créer cette colonne, nous utiliserons la fonction fct_collapse. Nous passons
type_trimmed à fct_collapse car c'est le facteur sur lequel nous voulons baser
notre nouvelle colonne, puis nous utilisons other equals other_categories. Cela
indiquera à la fonction que toutes les catégories contenues dans le vecteur
other_categories doivent être renommées en "autre". Maintenant, la ligne 4 a le
type "autre" au lieu de "poisson".
12. Réduire les catégories
Si nous comptons les catégories dans notre bloc de données maintenant, il n'y en
a que trois ! Cela facilite la comparaison de tous les autres animaux avec les
oiseaux et les mammifères.

13. Entraînons-nous !
Il est temps de résoudre vos propres problèmes de données catégoriques !

Identifier l'incohérence
Dans l'exercice vidéo, vous avez découvert différents types d'incohérences qui
peuvent se produire au sein des catégories, donnant l'impression qu'une variable
a plus de catégories qu'elle ne le devrait.

Dans cet exercice, vous continuerez à travailler avec l' sfo_survey ensemble de
données. Vous examinerez à dest_size nouveau la colonne ainsi que la
cleanliness colonne et déterminerez le type de problèmes, le cas échéant,
auxquels ces deux variables catégorielles sont confrontées.

Dplyr et est chargé et sfo_survey disponible.

Instructions 1
Comptez le nombre d'occurrences de chaque catégorie de la dest_size variable
de sfo_survey.
Instructions 2
Question
Sélectionnez l'énoncé qui décrit le plus précisément les catégories dans la
dest_size variable de sfo_survey.
Des réponses possibles
Les catégories dans dest_size ont un espace blanc incohérent.
Instructions 3
Comptez le nombre d'occurrences de chaque catégorie de la cleanliness variable
de sfo_survey.
Instructions 4
Question
Sélectionnez l'énoncé qui décrit le plus précisément les catégories dans la
cleanliness variable de sfo_survey.
Des réponses possibles
Les catégories dans cleanliness ont des majuscules incohérentes.

Corriger l'incohérence
Maintenant que vous avez identifié les dest_size incohérences d'espaces et de
cleanliness majuscules, vous utiliserez les nouveaux outils à votre disposition
pour corriger les valeurs incohérentes au sfo_survey lieu de supprimer
complètement les points de données, ce qui pourrait ajouter un biais à votre
ensemble de données si plus de 5 % des points de données doivent être
supprimés.

Dplyr et stringr sont chargés et sfo_survey disponibles.

Instructions
Ajoutez une colonne à sfo_survey appelé dest_size_trimmed qui contient les
valeurs de la dest_size colonne avec tous les espaces blancs de début et de fin
supprimés.
Ajoutez une autre colonne appelée cleanliness_lower qui contient les valeurs de
la cleanliness colonne converties en minuscules.
Comptez le nombre d'occurrences de chaque catégorie dans dest_size_trimmed.
Comptez le nombre d'occurrences de chaque catégorie dans cleanliness_lower.
Belle conversion en minuscules et superbe coupe ! Vous avez pu convertir des
données de sept catégories en données de quatre catégories, ce qui facilitera
votre analyse.
Réduire les catégories
L'une des tablettes sur lesquelles les participants ont rempli sfo_survey n'était
pas correctement configurée, ce qui permet à la réponse dest_region d'être du
texte libre au lieu d'un menu déroulant. Cela a entraîné certaines incohérences
dans la dest_region variable que vous devrez corriger dans cet exercice pour
vous assurer que les chiffres que vous rapportez à votre patron sont aussi précis
que possible.

Dplyr et forcats sont chargés et sfo_survey disponibles.

Instructions 1
Question
À partir de votre sortie de l'étape 1, quelles catégories doivent être réduites ?
Des réponses possibles
"EU", "eur", et "Europ"doivent être réduits à "Europe".
Vous avez réduit le nombre de catégories de 12 à 9 et vous pouvez maintenant
être sûr que 401 des participants à l'enquête se dirigeaient vers l'Europe.

Nettoyage des données de texte

1. Nettoyage des données textuelles
Dans la dernière leçon de ce chapitre, nous parlerons des différentes manières de
traiter les données de texte modifiées.

2. Qu'est-ce que les données textuelles ?

Avant de plonger, examinons quelques exemples de données textuelles. Les
noms, numéros de téléphone, adresses e-mail et mots de passe sont tous des
données textuelles. Les données textuelles sont très courantes, mais il peut être
difficile de les utiliser car elles peuvent être non structurées.

3. Problèmes de données non structurées

Étant donné que les données textuelles n'ont généralement pas une structure
cohérente, nous pouvons rencontrer un certain nombre de problèmes lorsque
nous travaillons avec. Le premier concerne les incohérences de formatage, car il
existe souvent plusieurs façons de formater la même information. Par exemple,
les numéros de téléphone peuvent être écrits de différentes manières avec ou
sans espaces, parenthèses, tirets et autres signes de ponctuation, et les numéros
de carte de crédit peuvent être écrits avec ou sans espaces. L'incohérence des
informations se produit lorsque différents points de données offrent différentes
quantités d'informations. Par exemple, un numéro de téléphone peut inclure un
code de pays, tandis que d'autres ne le peuvent pas, ou une personne peut
remplir un champ « nom » en utilisant son prénom et son nom, tandis qu'une
autre peut n'utiliser que son prénom. Les données saisies peuvent également être
invalides,

4. Données client
Pour en savoir plus sur la résolution de ces problèmes, nous examinerons un
exemple d'ensemble de données de clients contenant les noms des clients, les
entreprises et les numéros de carte de crédit. Notez que certaines lignes
comportent des espaces dans le numéro de carte de crédit tandis que d'autres
comportent des tirets. Des données textuelles sales comme celle-ci peuvent
interférer avec les pipelines et les processus qui reposent sur ces données. Par
exemple, un logiciel de vente peut uniquement traiter les numéros de carte de
crédit qui sont formatés de manière cohérente.

5. Détection des numéros de carte de crédit avec trait d'union

Pour nettoyer ces données textuelles, nous pouvons utiliser les fonctions du
package stringr. Avant de pouvoir nettoyer ces données, nous devons trouver
quelles valeurs doivent être nettoyées. Cela peut être fait à l'aide de la fonction
str_detect, qui prend un vecteur de caractères, dans ce cas la colonne de nom de
la trame de données clients, et le modèle que vous souhaitez détecter, qui est un
trait d'union. Cela renverra un vecteur logique indiquant si un tiret est trouvé
dans la colonne credit_card de chaque ligne.

6. Remplacement des traits d'union

Maintenant que nous avons identifié où se situent nos problèmes, nous pouvons
utiliser la fonction str_replace_all, qui prend dans la colonne de données
textuelles, la chaîne que nous voulons remplacer et la chaîne de remplacement.
Dans cet exemple, nous souhaitons remplacer tous les tirets de la colonne
credit_card par des espaces afin que tous les numéros de carte de crédit aient un
formatage cohérent.

7. Suppression des traits d'union et des espaces

Une solution alternative consiste à supprimer les tirets et les espaces des
numéros de carte de crédit afin qu'ils ne contiennent que des chiffres. Cela peut
être fait en utilisant la fonction str_remove_all. Ici, nous prenons la colonne
credit_card, supprimons tous les traits d'union, puis supprimons tous les espaces.
Nous pouvons l'ajouter à notre bloc de données en utilisant mutate.

8. Trouver des cartes de crédit invalides

Maintenant que nous avons supprimé tous les traits d'union et les espaces, tous
les numéros de carte de crédit devraient avoir exactement 16 chiffres. Nous
pouvons trouver des cartes de crédit invalides en utilisant la fonction str_length,
qui renvoie la longueur de chaque chaîne dans une colonne. str_length peut être
utilisé en combinaison avec un filtre pour trouver tous les clients dont le numéro
de carte de crédit ne contient pas exactement 16 caractères.

9. Supprimer les cartes de crédit invalides

Nous pouvons supprimer ces numéros non valides de l'ensemble de données en
filtrant les lignes qui ont une carte de crédit d'une longueur de 16. Nous
pourrons désormais facturer les clients facilement !

10. Problèmes de texte plus complexes

Pour traiter des problèmes de données de texte plus complexes, des expressions
régulières peuvent être utilisées. Une expression régulière est une séquence de
caractères qui permet une recherche robuste dans une chaîne. Par exemple, nous
pourrions rechercher toutes les cartes de crédit qui ont un 4 comme premier
chiffre. Dans les expressions régulières, certains caractères sont traités
différemment. Toutes les fonctions stringr que nous avons apprises utilisent des
expressions régulières, donc lors de la recherche ou du remplacement de l'un de
ces caractères spéciaux, la fonction fixe doit être enroulée autour du texte,
comme ceci. Nous n'aborderons pas davantage les expressions régulières, mais
consultez ces cours pour en savoir plus à leur sujet.
11. Entraînons-nous !

Détection de données textuelles incohérentes

Vous avez récemment reçu des nouvelles selon lesquelles l'équipe de support
client souhaite poser des questions de suivi aux participants à l'enquête SFO.
Cependant, le numéroteur automatique utilisé par le centre d'appels n'est pas en
mesure d'analyser tous les numéros de téléphone, car ils sont tous dans des
formats différents. Après quelques recherches, vous avez découvert que certains
numéros de téléphone sont écrits avec des tirets (-) et d'autres avec des
parenthèses ((,)). Dans cet exercice, vous découvrirez quels numéros de
téléphone présentent ces problèmes afin de savoir lesquels doivent être corrigés.

Dplyr et stringr sont chargés, et sfo_survey est disponible.

Instructions 1
Filtrez les lignes avec des numéros de téléphone contenant "-"s.
Instructions 2
Filter for rows with phone numbers that contain "(", or ")". Remember to use
fixed() when searching for parentheses.

Remplacement et suppression
Dans le dernier exercice, vous avez vu que la phonecolonne de sfo_dataest
infestée de parenthèses et de tirets inutiles. L'équipe de support client a demandé
que tous les numéros de téléphone soient au format "123 456 7890". Dans cet
exercice, vous utiliserez vos nouvelles stringrcompétences pour répondre à cette
demande.

dplyret stringr sont chargés et sfo_survey disponibles.

Instructions 1
Supprimez les parenthèses ouvrantes et fermantes de la phone colonne. Stockez-
le en tant que variable appelée phone_no_parens. N'oubliez pas d'utiliser fixed()!
Instructions 2
Ajoutez une nouvelle colonne à sfo_surveyappelé phone_no_parensqui contient
le contenu de phone_no_parens
Instructions 3
Créez une nouvelle colonne de sfo_survey appelés phone_clean contenant les
valeurs de phone_no_parens avec tous les tirets remplacés par des espaces.
Maintenant que vos numéros de téléphone sont tous dans un format unique, les
machines du centre d'appels pourront composer automatiquement les numéros,
ce qui facilitera les questions de suivi des participants.

Numéros de téléphone invalides

L'équipe de support client est reconnaissante pour votre travail jusqu'à présent,
mais au cours de leur premier jour d'appel des participants, ils ont rencontré des
numéros de téléphone invalides. Dans cet exercice, vous allez supprimer toutes
les lignes contenant des numéros de téléphone non valides afin que ces numéros
erronés ne ralentissent pas l'équipe.
dplyr and stringr are loaded and sfo_survey is available.
Instructions
Examinez les phone nombres invalides en filtrant les nombres dont la longueur
n'est pas égale à 12.
Supprimez les lignes contenant des numéros non valides en filtrant les numéros
d'une longueur d'exactement 12.

3- Problèmes de données avancés

Dans ce chapitre, vous vous plongerez dans des problèmes de nettoyage de
données plus avancés, tels que le fait de s'assurer que les poids sont tous écrits
en kilogrammes au lieu de livres. Vous acquerrez également des compétences
inestimables qui vous aideront à vérifier que les valeurs ont été ajoutées
correctement et que les valeurs manquantes n'ont pas d'impact négatif sur vos
analyses.

Uniformité
1. Uniformité
Super boulot sur le chapitre 2 ! Dans ce chapitre, nous nous concentrerons sur
des problèmes de nettoyage de données plus avancés.

2. Uniformité
Le premier problème que nous aborderons est l'uniformité. Les problèmes
d'uniformité surviennent lorsque les points de données continus ont des unités
ou des formats différents. Par exemple, la température peut être écrite en degrés
Celsius ou Fahrenheit, le poids peut être mesuré en kilogrammes, en grammes
ou en livres, l'argent peut être en dollars américains, en livres sterling ou même
en yens japonais, et les dates peuvent être écrites dans des ordres différents.

3. D'où viennent les problèmes d'uniformité ?

Des problèmes d'uniformité surviennent lorsque vous utilisez plusieurs sources
de données qui peuvent stocker des données de différentes manières, ou à partir
d'une entrée de données non structurée qui ne nécessite pas d'unités ou de
formatage spécifiques.

4. Trouver des problèmes d'uniformité

Jetons un coup d'œil à l'ensemble de données nyc_temps, qui contient les
températures moyennes quotidiennes à New York en avril 2019.

5. Trouver des problèmes d'uniformité

Étant donné que les valeurs aberrantes peuvent être un signe de problèmes
d'uniformité, il est généralement utile d'effectuer un tracé de base pour identifier
les valeurs aberrantes. Créons un nuage de points de l'ensemble de données.
Cela ne semble pas tout à fait correct - il y a trois températures inhabituellement
élevées. Une température extérieure de plus de 50 degrés Celsius serait très
préoccupante.

6. Que faire ?
Il n'y a pas de meilleure option pour traiter ces données. Afin de déterminer ce
qu'il faut faire, nous devrons faire des recherches plus approfondies sur
l'ensemble de données. Il n'y a pas eu de grands événements climatiques à New
York au cours de ce mois, il y a donc probablement autre chose avec ces
valeurs. Après avoir parlé avec la personne en charge de la collecte des données
de température, nous apprenons que ces trois jours, le thermomètre était cassé et
que les données devaient être extraites d'une autre source. Cependant, cette autre
source mesurait la température en degrés Fahrenheit au lieu de Celsius.

7. Conversion d'unités
Puisque nous savons exactement pourquoi ces points de données ne sont pas
uniformes, nous pouvons les ajuster pour qu'ils s'adaptent au reste des points de
données. Ici, nous avons la formule pour convertir la température en Fahrenheit
en Celsius. Nous voulons seulement appliquer cette formule à ceux qui sont en
Fahrenheit. Pour ce faire, nous utiliserons la fonction ifelse. ifelse prend une
condition, la valeur à utiliser si la condition est vraie et la valeur à utiliser si la
condition est fausse. Ajoutons une colonne à nyc_temps appelée temp_c. ifelse
vérifiera si la température d'origine est supérieure à 50, la convertira en Celsius
si c'est le cas et conservera la température d'origine dans le cas contraire. La
première température était déjà en degrés Celsius, donc temp_c contient la
même valeur, mais 58-point-5 a été converti en 14-point-7.

8. Conversion d'unités
Si nous créons le même nuage de points qu'avant d'utiliser la colonne temp_c,
les températures se situent toutes entre 4 et 20, ce qui correspond à ce que nous
attendions.

9. Uniformité des dates

Les dates peuvent également poser des problèmes d'uniformité, car il existe de
nombreuses façons de les écrire. Dans cet exemple, les dates sont écrites de trois
manières différentes. Nous pouvons utiliser des chaînes de formatage spéciales
pour les convertir en objets Date uniformes afin qu'ils soient tous écrits de la
même manière. Ce sont ceux dont nous aurons besoin pour cet ensemble de
données, mais il y en a tellement d'autres comme ceux-ci - vous pouvez toujours
le taper dans votre console R pour obtenir une liste de tous les formats de date
disponibles.

10. Analyser plusieurs formats

Pour convertir tous ces objets en objets Date, nous utiliserons la fonction
parse_date_time du package lubridate. On passe le vecteur de dates à convertir,
et un vecteur de chaînes de format à l'argument "orders". Celui-ci contient les
trois formats différents que nous avons vus dans notre bloc de données. Juste
comme ça, toutes les dates sont exactement dans le même format ! Si nous
essayons d'analyser une date qui n'est pas dans l'un des formats que nous avons
spécifiés, NA sera renvoyé à la place.

11. Dates ambiguës

Parfois, les dates peuvent être ambiguës et vous ne pourrez pas dire quel format
elles suivent. Par exemple, cette date est-elle en février ou en avril ? Comme
pour les autres tâches de nettoyage, cela dépend fortement de vos données et de
leur provenance. Une option consiste à traiter ces dates comme manquantes. Si
vos données proviennent de plusieurs sources, vous remarquerez peut-être
qu'une source utilise un format et une autre source utilise un format différent. À
partir de là, vous pourrez faire une supposition éclairée sur le format de la date
en fonction de la source d'où elle provient. Vous pouvez également essayer de
déterminer le format en fonction d'autres dates de l'ensemble de données. Si
vous savez qu'il devrait y avoir un point de données par date, vous pourrez peut-
être le comprendre.

12. Entraînons-nous !
Il est temps de pratiquer les conversions d'unité et de date !

Uniformité de la date
Dans ce chapitre, vous travaillez dans une société de gestion d'actifs et vous
travaillerez avec l' accounts ensemble de données, qui contient des informations
sur chaque client, le montant de son compte et la date d'ouverture de son
compte. Votre patron vous a demandé de calculer des statistiques récapitulatives
sur la valeur moyenne de chaque compte et si l'âge du compte est associé à une
valeur de compte supérieure ou inférieure. Avant de pouvoir le faire, vous devez
vous assurer que l' accounts ensemble de données qui vous a été fourni ne
contient aucun problème d'uniformité. Dans cet exercice, vous allez étudier la
date_opened colonne et la nettoyer afin que toutes les dates soient au même
format.
Dplyr et lubridate sont chargés et accounts disponibles.
Instructions 1
Jetez un œil à la tête de accounts pour avoir une idée des données avec
lesquelles vous travaillez.
Instructions 2
Question
Essayez d'exécuter as.Date(accounts$date_opened)dans la console et examinez
la sortie. Notez que vous vous retrouvez avec beaucoup de NAs. Pourquoi est-
ce?
Des réponses possibles
Par défaut, as.Date()impossible de convertir les formats "Mois JJ, AAAA".
Instructions 3
Convertissez les dates de la date_opened colonne au même format à l'aide du
formatsvecteur et stockez-le en tant que nouvelle colonne appelée
date_opened_clean.

Uniformité monétaire
Maintenant que vos dates sont en ordre, vous devrez corriger toute différence
d'unité. Lorsque vous tracez les données pour la première fois, vous remarquerez
qu'il existe un groupe de valeurs très élevées et un groupe de valeurs
relativement inférieures. La banque a deux bureaux différents - un à New York
et un à Tokyo, vous pensez donc que les comptes gérés par le bureau de Tokyo
sont en yen japonais au lieu de dollars américains. Heureusement, vous disposez
d'un bloc de données appelé account_officesqui indique quel bureau gère le
compte de chaque client, vous pouvez donc utiliser ces informations pour
déterminer lesquels totaldoivent être convertis de yens en dollars.
La formule pour convertir les yens en dollars est USD = JPY / 104.

dplyret ggplot2sont chargés et les trames de données accountset

account_officessont disponibles.
Instructions 1
Créez un nuage de points avec date_openedsur l'axe des x et totalsur l'axe des y.

Uniformité monétaire
Instructions 1
Créez un nuage de points avec date_opened sur l'axe des x et total sur l'axe des
y.
Instructions 2
Left join accounts and account_offices by their id columns.
Instructions 3
Créez un nuage de points de vos nouvelles données uniformes en utilisant
date_opened sur l'axe des x et total_usd sur l'axe des y.
Instructions 4
Créez un nuage de points de vos nouvelles données uniformes en utilisant
date_openedsur l'axe des x et total_usdsur l'axe des y.
Conversion de devises astucieuse! Les points de votre dernier nuage de points se
situent désormais tous dans une plage beaucoup plus petite et vous serez en
mesure d'évaluer avec précision les différences entre les comptes de différents
pays.

Validation croisée des champs

1. Validation croisée des champs
Dans cette leçon, nous parlerons de l'utilisation de la validation croisée pour
trouver des données modifiées.
2. Qu'est-ce que la validation croisée ?
La validation croisée est essentiellement une vérification de l'intégrité de vos
données pour vérifier qu'une valeur est logique en fonction des autres valeurs de
votre ensemble de données. Ici, 52 % et 58 % totalisent 110 %, ce qui n'a pas de
sens dans ce contexte, nous savons donc qu'une ou plusieurs de ces valeurs sont
fausses.

1 https://www.buzzfeednews.com/article/katienotopoulos/graphs-that-lied-to-us
3. Données de carte de crédit
Voici un bloc de données appelé credit_cards, qui contient des informations sur
les comptes de carte de crédit, y compris la date d'ouverture, le montant de la
remise en argent que le compte a reçu sur les repas, l'épicerie et l'essence, ainsi
que la remise en argent totale et l'âge de le compte.

4. Validation des nombres

Pour ce type de carte de crédit, il n'y a que trois catégories d'achats sur
lesquelles vous pouvez gagner de l'argent, nous savons donc que les trois
catégories doivent s'additionner au total.

5. Validation des nombres

Pour trouver des comptes dont les catégories ne correspondent pas au total, nous
pouvons d'abord créer une nouvelle colonne appelée theory_total, qui contient la
somme des remises en argent pour les repas, l'épicerie et l'essence. Ensuite, nous
pouvons filtrer les lignes où le total_théorique n'est pas égal au total_cb ou au
total réel. Nous avons deux lignes qui ne s'additionnent pas correctement.

6. Validation de la date et de l'âge

Nous pouvons également valider les dates et les âges de la même manière,
puisque nous savons que la différence entre la date d'aujourd'hui et la
date_opened devrait être l'âge du compte.

7. Calcul de l'âge
Pour calculer l'âge en années, nous prenons la date d'origine, dans ce cas le 9
septembre 2015, et utilisons l'opérateur pourcentage-moins-pourcentage suivi de
la fonction aujourd'hui. Cela calculera combien de temps s'est écoulé entre la
date d'origine et aujourd'hui. Cependant, cela renvoie un type de données
spécial, nous devrons donc le convertir en numérique en utilisant as-dot-
numeric. Nous passerons "années" entre guillemets comme deuxième argument
pour convertir l'intervalle de temps en nombre d'années. Enfin, si on ne veut que
le nombre d'années, on peut utiliser la fonction floor pour se débarrasser des
décimales.

8. Validation de l'âge
Nous pouvons utiliser la même stratégie de mutation et de filtrage que celle
utilisée lors de la validation des totaux de remise en argent. Nous allons créer
une colonne appelée theor_age pour contenir l'âge calculé et le comparer à l'âge
du compte. Nous avons deux comptes dont les âges ne correspondent pas.

9. Et ensuite ?
Une fois que nous trouvons ces données invalides, qu'en faisons-nous ? Tout
comme les autres problèmes de nettoyage de données, il n'existe pas de solution
unique, car trouver la meilleure solution dépend de l'ensemble de données. Nous
pouvons décider de supprimer des données incohérentes, de les définir comme
manquantes et de les imputer, ou d'appliquer certaines règles en utilisant la
connaissance du domaine, mais pour savoir quelle est la meilleure approche,
nous devons bien comprendre d'où vient l'ensemble de données et le différentes
sources qui l'alimentent.

10. Entraînons-nous !
Il est temps de faire une validation croisée par vous-même !

Validation des totaux

Dans cette leçon, vous continuerez à travailler avec le accountsbloc de données,
mais cette fois, vous disposez d'un peu plus d'informations sur chaque compte. Il
existe trois fonds différents dans lesquels les titulaires de compte peuvent
stocker leur argent. Dans cet exercice, vous allez vérifier si le totalmontant de
chaque compte est égal à la somme du montant dans fund_A, fund_B, et
fund_C. S'il y a des comptes qui ne correspondent pas, vous pouvez les
examiner plus avant pour voir ce qui n'a pas fonctionné dans la comptabilité qui
a conduit à des incohérences.

Dplyr est chargé et accounts disponible.

Instructions
Créez une nouvelle colonne appelée theoretical_total qui contient la somme des
montants dans chaque fonds.
Trouvez les comptes dont le total ne correspond pas au theoretical_total.

Validation de l'âge
Maintenant que vous avez trouvé des incohérences dans les totalmontants, vous
pensez qu'il peut également y avoir des incohérences dans la acct_agecolonne, et
vous voulez voir si ces incohérences sont liées. À l'aide des compétences que
vous avez acquises grâce à l'exercice vidéo, vous devrez valider l'âge de chaque
compte et voir si les lignes avec des acct_ages incohérents sont les mêmes qui
avaient des totals incohérents .

Dplyr et lubridate sont chargés, et accounts est disponible.

Instructions
Créez une nouvelle colonne appelée theoretical_age qui contient l'âge de chaque
compte en fonction du date_opened.
Trouvez les comptes dont le acct_age ne correspond pas au theoretical_age.

Types d'absence
Vous venez de découvrir les trois types de données manquantes : manquantes
complètement au hasard (MCAR), manquantes au hasard (MAR) et manquantes
non aléatoires (MNAR). Dans cet exercice, vous consoliderez vos nouvelles
connaissances en associant des exemples aux types d'absence.
Instructions
Faites glisser les exemples vers le type d'absence qui les décrit le mieux.
Types d'absence
Vous venez de découvrir les trois types de données manquantes : manquantes
complètement au hasard (MCAR), manquantes au hasard (MAR) et manquantes
non aléatoires (MNAR). Dans cet exercice, vous consoliderez vos nouvelles
connaissances en associant des exemples aux types d'absence.
Instructions
Faites glisser les exemples vers le type d'absence qui les décrit le mieux.

Visualiser les données manquantes

Traiter les données manquantes est l'une des tâches les plus courantes en science
des données. Il existe une variété de types de données manquantes, ainsi qu'une
variété de types de solutions aux données manquantes.

Vous venez de recevoir une nouvelle version de la accounts trame de données

contenant des données sur le montant détenu et le montant investi pour les
clients nouveaux et existants. Cependant, il y a des lignes avec des inv_amount
valeurs manquantes.

Vous savez pertinemment que la plupart des clients de moins de 25 ans n'ont pas
encore de compte d'investissement et soupçonnent que cela pourrait être à
l'origine de l'absence. Les packages dplyr et visdat ont été chargés et accounts
sont disponibles.
Instructions 1
Visualisez les valeurs manquantes accounts par colonne à l'aide d'une fonction
du visdat package.
Instructions 2
Ajoutez une colonne logique à accountsappelé missing_invqui indique si chaque
ligne manque inv_amountou non.
Regrouper par missing_inv.
Calculer l'âge moyen pour chaque groupe de missing_inv.
Instructions 3
Question
Jetez un œil à l'âge moyen de chaque groupe de missing_inv. Que se passe t-il
ici?
Des réponses possibles
Instructions 4
Trier accounts par age.
Visualisez les données manquantes par colonne.

Traiter les données manquantes

Dans cet exercice, vous travaillez avec une autre version des accounts données
qui contient des valeurs manquantes pour les colonnes cust_idet acct_amount.

Vous voulez savoir combien de clients uniques la banque a, ainsi que le montant
moyen détenu par les clients. Vous savez que les lignes manquantes cust_idne
vous aident pas vraiment, et qu'en moyenne, le acct_amount est généralement 5
fois le montant de inv_amount.

Dans cet exercice, vous allez supprimer les lignes de accounts avec des cust_ids
manquants et imputer les valeurs manquantes de inv_amount avec une certaine
connaissance du domaine. Dplyr et assertives ont chargés et accounts
disponibles.

Instructions 1
Filtrez accounts pour supprimer les lignes avec des cust_ids manquants et
enregistrez en tant que accounts_clean.
Instructions 2
Créez une nouvelle colonne appelée acct_amount_filled, qui contient les valeurs
de acct_amount, sauf que toutes les NA valeurs doivent être remplacées par 5
fois le montant de inv_amount.
Instructions 3
Affirmez qu'il n'y a pas de valeurs manquantes dans la cust_id colonne de
accounts_clean.
Instructions 4
Affirmez qu'il n'y a pas de valeurs manquantes dans la acct_amount_filled
colonne de accounts_clean.

4- Couplage d'enregistrements
Le couplage d'enregistrements est une technique puissante utilisée pour
fusionner plusieurs ensembles de données, utilisée lorsque les valeurs ont des
fautes de frappe ou des orthographes différentes. Dans ce chapitre, vous
apprendrez à lier des enregistrements en calculant la similarité entre les chaînes.
Vous utiliserez ensuite vos nouvelles compétences pour joindre deux ensembles
de données d'avis de restaurants en un seul ensemble de données maître propre.

Comparer des chaînes

1. Comparer des chaînes
Bienvenue dans le dernier chapitre du cours ! Dans ce chapitre, nous nous
concentrerons sur l'appariement de chaînes et le couplage d'enregistrements.

2. Mesurer la distance entre les valeurs

Si nous avons deux valeurs, un 3 et un 10,

3. Mesurer la distance entre les valeurs

nous pouvons mesurer la distance entre eux
4. Mesurer la distance entre les valeurs
en utilisant la soustraction. La distance entre eux est de 10 moins 3, ce qui fait 7.
Comparer des nombres est facile, mais comment comparer des chaînes ? Avant
de plonger dans le couplage d'enregistrements, nous devons apprendre à mesurer
la distance entre les chaînes.

5. Distance d'édition minimale

La distance d'édition est un moyen de mesurer à quel point deux chaînes sont
différentes l'une de l'autre, en fonction des quatre types de fautes de frappe de
base, qui consistent à insérer un caractère,

6. Distance d'édition minimale

supprimer un caractère,

7. Distance d'édition minimale

substituer un caractère à un autre,

8. Distance d'édition minimale

et transposer ou échanger les positions de deux caractères. La distance d'édition
minimale est le plus petit nombre de fautes de frappe dont vous auriez besoin
pour convertir une chaîne en une autre.

9. Modifier la distance = 1
Voici quelques exemples. Pour transformer "chien" en "chiens", nous insérons
un "s".

10. Modifier la distance = 1

Pour transformer "bain" en "bat", on enlève le "h".
11. Modifier la distance = 1
Pour transformer les « chats » en « rats », nous substituons un « r » au « c ».

12. Modifier la distance = 1

Pour transformer « chanter » en « signe », on échange les positions du « n » et
du « g ». Étant donné que toutes ces paires ne nécessitent qu'une seule édition,
elles ont toutes une distance d'édition de 1.

13. Un exemple plus complexe

Regardons un exemple plus complexe et calculons la distance d'édition entre
"babouin" et "typhon".

14. Un exemple plus complexe

Tout d'abord, nous devrons insérer un "h".

15. Un exemple plus complexe

Ensuite, nous devrons remplacer "t" par "b",

16. Un exemple plus complexe

remplacer "y" par "a",

17. Un exemple plus complexe

et remplacer "p" par "b". Cela nous donne un total de 4 actions, ou une distance
d'édition de 4.

18. Types de distance d'édition

Il existe plusieurs types de distance d'édition qui calculent chacun la distance
entre les chaînes de manière légèrement différente. La distance Damerau-
Levenshtein est ce que vous venez d'apprendre. La distance de Levenshtein ne
compte pas la transposition comme une seule action - au lieu de cela, elle
compte comme 2 : une suppression et une insertion. La distance de la plus
longue sous-séquence commune, ou LCS, considère uniquement l'insertion et la
suppression comme des actions. Il existe également d'autres méthodes plus
complexes de calcul de la distance de chaîne, telles que la distance Jaro-Winkler
ou Jaccard. Chaque méthode a un avantage relatif dans différentes circonstances,
mais entrer dans les détails du moment d'utilisation de chacune est hors de
portée du cours. Cependant, n'hésitez pas à expérimenter les différentes
méthodes et à utiliser celle qui vous donne les meilleurs résultats.

19. Distance entre les cordes en R

Revenons à notre exemple babouin-typhon. Pour calculer les distances d'édition
dans R, vous pouvez utiliser stringdist du package stringdist, en lui passant les
deux chaînes à comparer et la méthode que vous souhaitez utiliser. Dans ce cas,
nous utilisons "dl", qui signifie Damerau-Levenshtein.

20. Autres méthodes

En utilisant l'argument method, nous pouvons également calculer différents
types de distances dont nous avons discuté. La sortie de Jaccard est sur une
échelle de 0 à 1, où les nombres plus proches de 0 indiquent que les chaînes sont
plus similaires.

21. Comparer des chaînes pour nettoyer des données

Au chapitre 2, vous avez regroupé plusieurs catégories en une seule en utilisant
des catégories définies manuellement. Mais s'il y a trop de variations à saisir,
nous pouvons utiliser la distance de chaîne pour les mapper à la bonne catégorie.

22. Comparer des chaînes pour nettoyer des données

Voici une enquête dans laquelle on a demandé aux participants de New York,
Chicago, Los Angeles et Seattle où ils habitent actuellement et quelle est leur
probabilité d'envisager de déménager sur une échelle de 1 à 5. L'enquête
comportait une entrée de texte libre, donc la ville colonne est truffée de fautes de
frappe. Pour les mettre en correspondance avec l'orthographe correcte, nous
pouvons comparer la distance entre chaque réponse à l'enquête et l'ensemble des
réponses possibles, et choisir celle qui est la plus proche.
23. Remappage à l'aide de la distance de chaîne
Le package fuzzyjoin nous permet d'effectuer des jointures en fonction de la
distance de la chaîne. Nous pouvons utiliser stringdist_left_join pour joindre les
données d'enquête aux villes. Tout comme la fonction stringdist, nous pouvons
transmettre la méthode que nous voulons utiliser pour la distance de chaîne.

24. Remappage à l'aide de la distance de chaîne

Nous pouvons également utiliser l'argument max_dist pour ajuster à quel point
nous voulons que les chaînes soient proches afin de les considérer comme une
correspondance. Remarquez comment nous obtenons un NA, puisque la faute de
frappe de la ligne 8 n'était pas assez proche d'aucune des villes pour être
attribuée à une.

25. Entraînons-nous !
Il est temps de comparer les cordes !

Calcul de la distance
Dans l'exercice vidéo, vous avez vu comment utiliser la distance Damerau-
Levenshtein pour identifier la similitude de deux cordes. Pour rappel, la distance
Damerau-Levenshtein est lanombre minimum d'étapesnécessaire pour passer de
la chaîne A à la chaîne B , en utilisant ces opérations :

Insertion d'un nouveau personnage.

Suppression d'un caractère existant.
Remplacement d'un personnage existant.
Transposition de deux caractères consécutifs existants.
Quelle est la distance Damerau-Levenshtein entre les mots "puffin"et
"muffins"et quelle(s) opération(s) vous y amène ?
Instructions
Des réponses possibles
2 en substituant "m"à "p"et à insérer "s"

Petite distance, petite différence

Dans l'exercice vidéo, vous avez appris qu'il existe plusieurs façons de calculer
la similitude ou la différence entre deux chaînes. Vous allez maintenant vous
entraîner à utiliser le stringdist package pour calculer les distances de chaîne à
l'aide de diverses méthodes. Il est important de se familiariser avec les
différentes méthodes, car certaines méthodes fonctionnent mieux sur certains
ensembles de données, tandis que d'autres fonctionnent mieux sur d'autres
ensembles de données.

Le stringdist paquet a été chargé pour vous.

Instructions 1
Calculez la distance Damerau-Levenshtein entre "las angelos"et "los angeles".
Instructions 2
Calculez la distance de la plus longue sous-chaîne commune (LCS) entre "las
angelos"et "los angeles"
Instructions 3
Calculez la distance Jaccard entre "las angelos"et "los angeles".
Instructions 4
Question
Pourquoi la distance LCS est-elle plus élevée que la distance Damerau-
Levenshtein entre "las angelos"et "los angeles"?
La distance LCS utilise uniquement l'insertion et la suppression, il faut donc
plus d'opérations pour changer une chaîne en une autre.

Correction des fautes de frappe avec la distance de chaîne

Dans ce chapitre, l'un des ensembles de données avec lesquels vous allez
travailler, zagat, est un ensemble de restaurants à New York, Los Angeles,
Atlanta, San Francisco et Las Vegas. Les données proviennent de Zagat, une
entreprise qui recueille des critiques de restaurants et comprend les noms,
adresses, numéros de téléphone des restaurants, ainsi que d'autres informations
sur les restaurants.

La citycolonne contient le nom de la ville dans laquelle se trouve le restaurant.

Cependant, il y a un certain nombre de fautes de frappe dans la colonne. Votre
tâche consiste à mapper chacune citysur l'une des cinq villes correctement
orthographiées contenues dans le citiesbloc de données.

Dplyr et fuzzyjoin sont chargés, et zagat et cities sont disponibles.

Instructions 1
Comptez le nombre de chaque variation de city nom dans zagat.
Instructions 2
Jointure à gauche zagat et cities basée sur la distance de chaîne à l'aide des
colonnes city et city_actual.
Sélectionnez les name, city et les city_actual colonnes.

Lien ou rejoindre?
Semblable aux jointures, le couplage d'enregistrements consiste à relier des
données provenant de différentes sources concernant la même entité. Mais
contrairement aux jointures, le couplage d'enregistrements ne nécessite pas de
correspondances exactes entre différentes paires de données et peut à la place
trouver des correspondances proches en utilisant la similarité de chaîne. C'est
pourquoi le couplage d'enregistrements est efficace lorsqu'il n'y a pas de clés
uniques communes entre les sources de données sur lesquelles vous pouvez vous
fier lors du couplage de sources de données, comme un identifiant unique.

Dans cet exercice, vous déciderez quelle méthode est la meilleure pour résoudre
chaque problème.
Instructions
Déterminez quels problèmes nécessitent un couplage d'enregistrements et quels
problèmes peuvent être abordés à l'aide d'une jointure standard.

Blocage de paire
Zagat et Fodor's sont deux sociétés qui recueillent des critiques de restaurants.
Les zagat et les fodors ensembles de données contiennent tous deux des
informations sur divers restaurants, y compris les adresses, les numéros de
téléphone et les types de cuisine. Certains restaurants apparaissent dans les deux
ensembles de données, mais n'ont pas nécessairement le même nom ou numéro
de téléphone exact. Dans ce chapitre, vous vous efforcerez de déterminer quels
restaurants apparaissent dans les deux ensembles de données.

La première étape vers cet objectif consiste à générer des paires

d'enregistrements afin de pouvoir les comparer. Dans cet exercice, vous allez
d'abord générer toutes les paires possibles, puis utiliser votre city colonne
nouvellement nettoyée comme variable de blocage.

Zagat et fodors sont disponibles.

Instructions 1
Chargez le reclin paquet.
Générez toutes les paires d'enregistrements possibles entre les ensembles de
données zagat et fodors.
Instructions 2
Utilisez le blocage de paires pour générer uniquement les paires qui ont des
valeurs correspondantes dans la city colonne.
Des accords parfaits ! En l'utilisant citycomme variable de blocage, vous avez
pu réduire le nombre de paires à comparer de 165 230 paires à 40 532.

Comparer des paires

Maintenant que vous avez généré les paires de restaurants, il est temps de les
comparer. Vous pouvez facilement personnaliser la façon dont vous effectuez
vos comparaisons à l'aide des arguments by et default_comparator. Il n'y a pas
de bonne réponse quant à ce que chacun doit être défini, donc dans cet exercice,
vous allez essayer quelques options.

Dplyr et reclin sont chargés et zagat et fodors sont disponibles.

Instructions 1
Comparez les paires en name utilisant la lcs() distance.
Instructions 2
Paires par comparaison name, phone et l' addr utilisation jaro_winkler().
Comparaisons astucieuses! Le choix d'un comparateur et des colonnes à
comparer dépend fortement de l'ensemble de données, il est donc préférable
d'essayer différentes combinaisons pour voir celle qui fonctionne le mieux sur
l'ensemble de données avec lequel vous travaillez. Ensuite, vous développerez
vos compétences en comparaison de chaînes et découvrirez le couplage
d'enregistrements !

Notation et enchaînement
1. Notation et liens
Maintenant que nous avons comparé nos paires, il est temps de les noter et de
relier les données entre elles.

2. Dernière leçon
Dans la dernière leçon, nous avons travaillé avec ces deux blocs de données

3. Là où nous nous sommes arrêtés

et appris à créer et comparer des paires d'enregistrements. N'oubliez pas que les
colonnes x et y contiennent les numéros de ligne de chaque paire. Cependant,
tous les résultats de comparaison sont séparés par colonne, nous devrons donc
les combiner.
4. Marquer les paires
C'est là qu'intervient la notation.

5. Score avec des sommes

Une façon de combiner les partitions séparées est de les additionner.

6. Sommation
Nous pouvons le faire en utilisant score_simsum, qui créera une nouvelle
colonne appelée simsum qui contiendra le score total pour chaque ligne.

7. Somme
Nous pouvons voir que le score le plus élevé se situe entre la ligne 2 de df_A et
la ligne 3 de df_B, qui font toutes deux référence à un dénommé Keaton Snyder.

8. Inconvénients de la sommation
Cependant, la somme ne tient pas compte du fait qu'avoir un nom très similaire
est un indicateur plus fort que les enregistrements se réfèrent à la même
personne, alors qu'avoir le même sexe ne nous en dit pas autant. Au lieu de
sommer, nous pouvons utiliser une méthode de notation probabiliste qui tient
compte de ces différences entre les variables.

9. Notation probabiliste
Nous pouvons utiliser la fonction score_problink, qui nous donne un poids pour
chaque ligne. Plus le poids est élevé, plus la paire est similaire. Le poids le plus
élevé se situe à nouveau entre Keaton Z Snyder et Keaton Snyder.

10. Lier les paires

Maintenant que nous avons marqué chaque paire, comment choisissons-nous
celles qui correspondent ?
11. Sélection des matchs
Nous pouvons sélectionner les paires que nous considérons comme des
correspondances en utilisant select_n_to_m. Cela sélectionnera les
correspondances avec les scores les plus élevés, garantissant que tout
enregistrement dans un bloc de données n'est lié qu'à un seul enregistrement
dans l'autre bloc de données au maximum. Ici, la seule paire considérée comme
une correspondance est la ligne 2 de df_A et la ligne 3 de df_B.

12. Lier les données

Maintenant que nous avons sélectionné les paires qui correspondent, nous
pouvons enfin lier les deux trames de données ensemble à l'aide de la fonction
de liaison.

13. Données liées

Le côté gauche contient les données de df_A et le côté droit contient les données
de df_B. La première ligne contient des données des deux côtés, car c'est la
correspondance que nous avons trouvée, tandis que le reste des personnes n'a été
trouvée que dans l'une des deux trames de données.

14. Entraînons-nous !
Maintenant que vous avez appris à lier des données, entraînons-nous !

Marquer puis sélectionner ou sélectionner puis marquer ?

Le couplage d'enregistrements nécessite un certain nombre d'étapes qui peuvent
être difficiles à suivre. Dans cet exercice, vous consoliderez vos connaissances
sur le processus de couplage d'enregistrements afin que ce soit un jeu d'enfant
lorsque vous le codez vous-même !

Instructions
Faites glisser les étapes du processus de couplage d'enregistrements dans le bon
ordre.
Réponses
1- Nettoyez les ensembles de données
2- Générez des paires d’enregistrements
3- Comparez des colonnes distinctes de chaque paire
4- Scores des paires en utilisant la sommation ou la probabilité
5- Sélectionnez les paires qui correspondent en fonctions de leur score
6- Reliez les ensembles de données entre eux

Mettre ensemble
Au cours de ce chapitre, vous avez nettoyé la city colonne d' zagat utilisation de
la similarité de chaîne, ainsi que généré et comparé des paires de restaurants à
partir de zagat et fodors. La fin est proche - tout ce qu'il vous reste à faire est de
marquer et de sélectionner des paires et de relier les données ensemble, et vous
pourrez commencer votre analyse en un rien de temps !

Reclin et dplyr sont chargés et zagat et fodors sont disponibles.

Instructions 1
Noter les paires d'enregistrements de manière probabiliste.
Instructions 2
Sélectionnez les paires qui sont considérées comme des correspondances.
Instructions 3
Reliez les deux blocs de données ensemble.
Joli lien ! Maintenant que vos deux ensembles de données sont fusionnés, vous
pouvez utiliser les données pour déterminer s'il existe certaines caractéristiques
qui rendent un restaurant plus susceptible d'être examiné par Zagat ou Fodor's.

Toutes nos félicitations!

1. Félicitations !

Félicitations pour avoir terminé le cours! Vous êtes maintenant équipé de

compétences en nettoyage de données.

2. Ce que vous avez appris

Dans ce cours, vous avez appris à diagnostiquer les données modifiées, quels
sont les effets secondaires des données modifiées et comment elles peuvent
avoir un impact sur une analyse, et comment nettoyer les données pour éviter
ces effets secondaires.

3. Chapitre 1 : Problèmes de données courants

Au chapitre 1, vous avez appris les contraintes de type, les contraintes de plage
et les contraintes d'unicité.

4. Chapitre 2 : Texte et données catégorielles

Au chapitre 2, vous avez découvert les problèmes spécifiques aux données
textuelles et catégorielles, notamment les contraintes d'appartenance, le
nettoyage des variables catégorielles et le nettoyage des données textuelles.

5. Chapitre 3 : Problèmes de données avancés

Dans le chapitre 3, vous avez examiné des problèmes de données plus avancés,
comme l'unification de données formatées de manière incohérente, la validation
croisée et le traitement des données manquantes.

6. Chapitre 4 : Couplage d'enregistrements

Au chapitre 4, vous avez appris à utiliser le couplage d'enregistrements pour lier
des ensembles de données lorsque les jointures traditionnelles ne peuvent pas
être utilisées.

7. Développez et développez vos nouvelles compétences

Il y a encore beaucoup à apprendre pour devenir un expert en nettoyage de
données ! Consultez ces cours où vous pouvez en savoir plus sur l'utilisation de
données catégorielles, la manipulation de données textuelles et l'écriture de code
R propre pour empêcher les données sales en premier lieu.

8. Félicitations !
N'oubliez pas d'appliquer les précieuses compétences que vous avez acquises à
vos propres tâches de données. Félicitations, et amusez-vous à apprendre!