0Pricing
R Academy · Leçon

Tokenisation et suppression des mots vides

Découpez le texte en jetons et filtrez les mots peu informatifs avec anti_join().

Tokenisation et suppression des mots vides est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Qu’est-ce que l’exploration de textes ?

L’exploration de textes (ou analyse de textes) transforme du texte non structuré en données structurées pouvant être analysées statistiquement. Le package tidytext permet une approche tidy : chaque ligne correspond à un token (mot, bigramme ou phrase), ce qui le rend compatible avec dplyr et ggplot2.

library(tidytext)
library(dplyr)

# A simple text corpus
text_df <- tibble::tibble(
  doc_id = 1:3,
  text   = c(
    'The quick brown fox jumps over the lazy dog.',
    'Text mining with R is powerful and fun.',
    'Natural language processing enables many applications.'
  )
)

cat('Input: ', nrow(text_df), 'documents\n')
cat('Columns:', names(text_df), '\n')

unnest_tokens : tokenisation des mots

unnest_tokens(output, input) divise le texte pour obtenir une ligne par token. Par défaut, la tokenisation se fait mot par mot, avec conversion en minuscules et suppression de la ponctuation. L’argument token accepte notamment 'words', 'ngrams' et 'sentences'.

library(tidytext)
library(dplyr)

text_df <- tibble::tibble(
  doc_id = 1:2,
  text   = c(
    'R is a great language for data analysis.',
    'Text mining reveals hidden patterns in documents.'
  )
)

# Tokenise into words
tokens <- text_df |>
  unnest_tokens(word, text)

cat('Tokens extracted:', nrow(tokens), '\n')
print(tokens)

Le jeu de données stop_words

tidytext inclut un tibble stop_words contenant 1 149 mots vides anglais courants provenant de trois lexiques : SMART, Snowball et onix. Ces mots (the, is, and…) portent peu de sens sémantique et sont généralement supprimés avant l’analyse.

library(tidytext)
library(dplyr)

# Inspect the stop_words dataset
cat('Total stop words:', nrow(stop_words), '\n')
cat('Lexicons:', paste(unique(stop_words$lexicon), collapse = ', '), '\n')

# First few stop words from each lexicon
stop_words |>
  group_by(lexicon) |>
  slice_head(n = 3) |>
  print()

anti_join : supprimer les mots vides

anti_join(tokens, stop_words, by = 'word') supprime toutes les lignes dont la valeur de word correspond à une entrée de stop_words. Il s’agit de la méthode standard de tidytext pour supprimer les mots vides : elle est claire, lisible et facile à étendre.

library(tidytext)
library(dplyr)

text_df <- tibble::tibble(
  doc_id = 1:3,
  text   = c(
    'The quick brown fox jumps over the lazy dog',
    'A stitch in time saves nine important words',
     'To be or not to be that is the question'
  )
)

tokens <- text_df |>
  unnest_tokens(word, text)

cat('Before removing stop words:', nrow(tokens), '\n')

tokens_clean <- tokens |>
  anti_join(stop_words, by = 'word')

cat('After removing stop words:', nrow(tokens_clean), '\n')
print(tokens_clean)

count : fréquence des termes

Après la tokenisation et la suppression des mots vides, utilisez count(word, sort = TRUE) pour calculer la fréquence des termes. C’est la base de nombreuses analyses de textes : les mots porteurs de sens les plus fréquents caractérisent les thèmes du document.

library(tidytext)
library(dplyr)

# Use Jane Austen's novels from janeaustenr package
# For demo: simulate a small corpus
corpus <- tibble::tibble(
  text = c(
    'data science involves statistics programming analysis',
    'machine learning algorithms data patterns training',
    'statistics probability distributions random variables data',
    'programming languages python r julia statistics',
    'analysis patterns distributions algorithms science'
  )
)

word_counts <- corpus |>
  unnest_tokens(word, text) |>
  anti_join(stop_words, by = 'word') |>
  count(word, sort = TRUE)

cat('Top 8 words:\n')
print(head(word_counts, 8))

Mots vides personnalisés

Les corpus propres à un domaine contiennent souvent des mots très fréquents mais sans intérêt (par exemple patient ou doctor dans des notes médicales). Créez un tibble de mots vides personnalisés et fusionnez-le avec le lexique intégré à l’aide de bind_rows().

library(tidytext)
library(dplyr)

# Domain-specific words to remove
custom_stops <- tibble::tibble(
  word   = c('data', 'analysis', 'r', 'using', 'also'),
  lexicon = 'custom'
)

# Combine with built-in stop words
all_stops <- bind_rows(stop_words, custom_stops)
cat('Total stop words after custom:', nrow(all_stops), '\n')

corpus <- tibble::tibble(
  text = c(
    'Using R for data analysis and machine learning models',
    'Statistical data analysis also involves data visualisation'
  )
)

clean_tokens <- corpus |>
  unnest_tokens(word, text) |>
  anti_join(all_stops, by = 'word') |>
  count(word, sort = TRUE)

print(clean_tokens)

Tokenisation des bigrammes

Définissez token = 'ngrams', n = 2 pour effectuer une tokenisation en paires de mots consécutifs (bigrammes). Les bigrammes capturent des expressions comme machine learning ou data science, que les mots pris individuellement ne permettent pas de repérer, et fournissent ainsi un contexte plus riche.

library(tidytext)
library(dplyr)

corpus <- tibble::tibble(
  doc_id = 1:2,
  text = c(
    'machine learning and deep learning are powerful techniques',
    'natural language processing uses machine learning methods'
  )
)

bigrams <- corpus |>
  unnest_tokens(bigram, text, token = 'ngrams', n = 2)

cat('Bigrams extracted:', nrow(bigrams), '\n')
print(bigrams)

# Count most common bigrams
bigram_counts <- bigrams |> count(bigram, sort = TRUE)
cat('\nTop bigrams:\n')
print(head(bigram_counts, 5))

Filtrer les bigrammes pour améliorer la qualité

Les bigrammes les plus fréquents comprennent souvent des paires de mots vides comme of the. Séparez le bigramme en deux colonnes avec tidyr::separate(), filtrez les lignes où l’un ou l’autre mot est un mot vide, puis réunissez-les pour obtenir des paires d’expressions pertinentes.

library(tidytext)
library(dplyr)
library(tidyr)

corpus <- tibble::tibble(
  text = c(
    'the field of machine learning and deep learning is growing',
    'natural language processing is a subfield of artificial intelligence'
  )
)

bigrams_filtered <- corpus |>
  unnest_tokens(bigram, text, token = 'ngrams', n = 2) |>
  separate(bigram, into = c('word1', 'word2'), sep = ' ') |>
  filter(
    !word1 %in% stop_words$word,
    !word2 %in% stop_words$word
  ) |>
  unite(bigram, word1, word2, sep = ' ') |>
  count(bigram, sort = TRUE)

print(bigrams_filtered)

Visualiser les fréquences des mots

Représentez les fréquences des mots sous forme d’histogramme avec ggplot2. Triez les barres avec reorder(word, n) et utilisez coord_flip() pour obtenir des étiquettes horizontales. C’est l’un des résultats les plus parlants de l’exploration de textes.

library(tidytext)
library(dplyr)
library(ggplot2)

corpus <- tibble::tibble(
  text = c(
    'statistics probability machine learning algorithms patterns',
    'data science programming analysis visualisation models',
    'machine learning deep learning neural networks patterns',
    'probability statistics hypothesis testing distributions',
    'algorithms optimisation gradient descent models training'
  )
)

top_words <- corpus |>
  unnest_tokens(word, text) |>
  anti_join(stop_words, by = 'word') |>
  count(word, sort = TRUE) |>
  slice_head(n = 10)

ggplot(top_words, aes(reorder(word, n), n)) +
  geom_col(fill = 'steelblue') +
  coord_flip() +
  labs(x = 'Word', y = 'Count', title = 'Top 10 Terms') +
  theme_minimal()

Comptage des mots par document

Lorsque votre corpus contient plusieurs documents, ajoutez une colonne identifiant le document et regroupez les données par doc_id, word afin de calculer la fréquence des termes pour chaque document. Cette étape alimente directement les analyses TF-IDF et les modèles de thèmes.

library(tidytext)
library(dplyr)

docs <- tibble::tibble(
  doc_id = c(1, 1, 1, 2, 2, 2, 3, 3, 3),
  text   = c(
    'machine learning models training',
    'neural networks deep learning',
    'algorithms gradient descent optimisation',
    'statistical analysis probability distributions',
    'hypothesis testing confidence intervals regression',
    'bayesian inference prior posterior likelihood',
    'data visualisation plots charts dashboards',
    'ggplot2 ggvis plotly interactive graphics',
    'colour scales aesthetics themes layers'
  )
)

word_counts <- docs |>
  unnest_tokens(word, text) |>
  anti_join(stop_words, by = 'word') |>
  count(doc_id, word, sort = TRUE)

cat('Word-doc pairs:', nrow(word_counts), '\n')
print(head(word_counts, 10))

Tokenisation des phrases

Définissez token = 'sentences' pour séparer le texte aux limites des phrases. Les tokens au niveau de la phrase sont utiles pour l’analyse des sentiments (évaluer chaque phrase), le résumé (sélectionner les phrases représentatives) et les tâches de questions-réponses.

library(tidytext)
library(dplyr)

doc <- tibble::tibble(
  id   = 1L,
  text = paste(
    'R is a statistical programming language.',
    'It is widely used in data science and machine learning.',
    'The tidyverse makes data manipulation easy.',
    'Text mining with tidytext is elegant and powerful.'
  )
)

sentences <- doc |>
  unnest_tokens(sentence, text, token = 'sentences')

cat('Sentences found:', nrow(sentences), '\n')
print(sentences$sentence)

Vérification rapide

Vous avez tokenisé un corpus en mots avec unnest_tokens() et souhaitez supprimer les mots anglais courants. Quelle opération permet de le faire à l’aide du jeu de données intégré stop_words ?

Récapitulatif : tokenisation et mots vides

Points essentiels :

  • unnest_tokens(word, text) convertit le texte brut en un format tidy avec une ligne par mot
  • Par défaut : conversion en minuscules et suppression de la ponctuation ; prise en charge de 'words', 'ngrams' et 'sentences'
  • stop_words est un tibble intégré contenant 1 149 mots anglais courants issus de 3 lexiques
  • anti_join(tokens, stop_words, by = 'word') supprime les mots vides
  • Combinez-le avec bind_rows() pour ajouter des mots vides propres à votre domaine
  • count(word, sort = TRUE) calcule la fréquence des termes à partir des tokens tidy
  • Bigrammes : unnest_tokens(bigram, text, token = 'ngrams', n = 2)
library(tidytext)
library(dplyr)

tibble::tibble(text = 'The quick brown fox jumps over the lazy dog') |>
  unnest_tokens(word, text) |>
  anti_join(stop_words, by = 'word') |>
  count(word, sort = TRUE) |>
  print()

Questions Fréquemment Posées

La leçon « Tokenisation et suppression des mots vides » est-elle gratuite ?

Oui — le texte complet de « Tokenisation et suppression des mots vides » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tokenisation et suppression des mots vides » ?

Découpez le texte en jetons et filtrez les mots peu informatifs avec anti_join(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Tokenisation et suppression des mots vides » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Tokenisation et suppression des mots vides
  2. TF-IDF et analyse de la fréquence des termes
  3. Analyse des sentiments dans R
  4. Modélisation des thèmes avec LDA
← Retour à R Academy