R Academy · Les

Tokenisatie en stopwoorden verwijderen

Splits tekst op in tokens en filter niet-informatieve woorden met anti_join().

Les 1 van 413 stappen

Tokenisatie en stopwoorden verwijderen is een gratis R Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.

Wat is tekstmining?

Tekstmining (of tekstanalyse) zet ongestructureerde tekst om in gestructureerde gegevens die statistisch kunnen worden geanalyseerd. Het pakket tidytext maakt een tidy-aanpak mogelijk: elke rij is één token (woord, bigram of zin), waardoor de gegevens compatibel zijn met dplyr en 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: woorden tokeniseren

unnest_tokens(output, input) splitst tekst op in een indeling met één rij per token. Standaard wordt op woordniveau getokeniseerd, worden woorden omgezet naar kleine letters en wordt interpunctie verwijderd. Het argument token ondersteunt 'words', 'ngrams', 'sentences' en meer.

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)

De gegevensset stop_words

tidytext bevat standaard een ingebouwde tibble stop_words met 1.149 veelvoorkomende Engelse stopwoorden uit drie lexicons: SMART, Snowball en onix. Deze woorden ("the", "is", "and"…) hebben weinig semantische betekenis en worden doorgaans vóór de analyse verwijderd.

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: stopwoorden verwijderen

anti_join(tokens, stop_words, by = 'word') verwijdert alle rijen waarvan word overeenkomt met een item in stop_words. Dit is het standaardpatroon in tidytext voor het verwijderen van stopwoorden: overzichtelijk, leesbaar en eenvoudig uit te breiden.

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: termfrequentie

Gebruik na het tokeniseren en verwijderen van stopwoorden count(word, sort = TRUE) om de termfrequentie te berekenen. Dit vormt de basis van veel tekstmininganalyses: de meest frequente betekenisvolle woorden kenmerken de onderwerpen van het 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))

Aangepaste stopwoorden

Corpora uit een specifiek domein bevatten vaak veel voorkomende woorden die niet relevant zijn (bijvoorbeeld "patient" en "doctor" in medische notities). Maak een aangepaste tibble met stopwoorden en voeg die met bind_rows() toe aan het ingebouwde lexicon.

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)

Bigramtokenisatie

Stel token = 'ngrams', n = 2 in om opeenvolgende woordparen (bigrams) te maken. Bigrams vangen uitdrukkingen zoals "machine learning" of "data science" op die afzonderlijke woorden missen, waardoor meer context beschikbaar komt.

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))

Bigrams filteren op kwaliteit

De meest frequente bigrams bevatten vaak paren met stopwoorden, zoals "of the". Splits het bigram met tidyr::separate() op in twee kolommen, filter rijen weg waarin een van beide woorden een stopwoord is en voeg de woorden daarna weer samen om betekenisvolle uitdrukkingsparen te krijgen.

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)

Woordfrequenties visualiseren

Maak met ggplot2 een staafdiagram van woordfrequenties. Sorteer de staven met reorder(word, n) en gebruik coord_flip() voor horizontale labels. Dit is een van de meest communicatieve resultaten in tekstmining.

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()

Woordaantallen per document

Wanneer je corpus meerdere documenten bevat, voeg je een kolom met een document-ID toe en groepeer je met doc_id, word om de termfrequenties per document te berekenen. Dit vormt rechtstreeks de invoer voor TF-IDF- en topicmodelanalyses.

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))

Zinnen tokeniseren

Stel token = 'sentences' in om tekst op zinsgrenzen te splitsen. Tokens op zinsniveau zijn nuttig voor sentimentanalyse (elke zin scoren), samenvatting (representatieve zinnen selecteren) en vraag-en-antwoordtaken.

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)

Korte controle

Je hebt een corpus met unnest_tokens() in woorden opgesplitst en wilt veelvoorkomende Engelse woorden verwijderen. Welke bewerking bereikt dit met de ingebouwde gegevensset stop_words?

Beantwoord dit in de interactieve les

Samenvatting: tokenisatie en stopwoorden

Belangrijkste punten:

unnest_tokens(word, text) zet onbewerkte tekst om naar een tidy-indeling met één rij per woord
Standaard: kleine letters, interpunctie verwijderen; ondersteunt 'words', 'ngrams', 'sentences'
stop_words is een ingebouwde tibble met 1.149 veelvoorkomende Engelse woorden uit 3 lexicons
anti_join(tokens, stop_words, by = 'word') verwijdert stopwoorden
Combineer met bind_rows() om aangepaste domeinspecifieke stopwoorden toe te voegen
count(word, sort = TRUE) berekent de termfrequentie uit tidy-tokens
Bigrams: 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()

Gratis beginnen

Leer R met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 43
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Tokenisatie en stopwoorden verwijderen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “Tokenisatie en stopwoorden verwijderen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.

Wat leer ik in “Tokenisatie en stopwoorden verwijderen”?

Splits tekst op in tokens en filter niet-informatieve woorden met anti_join(). Je oefent met R Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met R Academy te beginnen?

Ervaring vooraf is niet nodig. R Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Tokenisatie en stopwoorden verwijderen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over R Academy?

Ja. Elke les over R Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar R Academy