R Academy · Lekcja

Tokenizacja i usuwanie słów pustych

Dziel tekst na tokeny i filtruj nieinformacyjne słowa za pomocą anti_join().

Tokenizacja i usuwanie słów pustych to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Czym jest eksploracja tekstu?

Eksploracja tekstu (zwana również analizą tekstu) przekształca nieustrukturyzowany tekst w ustrukturyzowane dane, które można analizować statystycznie. Pakiet tidytext umożliwia stosowanie podejścia tidy: każdy wiersz zawiera jeden token (słowo, bigram lub zdanie), dzięki czemu dane są zgodne z dplyr i 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: tokenizacja słów

unnest_tokens(output, input) dzieli tekst na format, w którym każdy wiersz odpowiada jednemu tokenowi. Domyślnie tokenizuje tekst według słów, zamieniając je na małe litery i usuwając interpunkcję. Argument token obsługuje wartości 'words', 'ngrams', 'sentences' i inne.

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)

Zbiór danych stop_words

Pakiet tidytext zawiera wbudowany tibble stop_words obejmujący 1149 często używanych angielskich słów nieznaczących z trzech leksykonów: SMART, Snowball i onix. Słowa te ("the", "is", "and"…) niosą niewiele znaczenia semantycznego i zazwyczaj usuwa się je przed analizą.

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: usuwanie słów nieznaczących

anti_join(tokens, stop_words, by = 'word') usuwa wszystkie wiersze, w których word odpowiada dowolnemu wpisowi w stop_words. Jest to standardowy schemat usuwania słów nieznaczących w pakiecie tidytext — przejrzysty, czytelny i łatwy do rozszerzania.

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: częstość terminów

Po tokenizacji i usunięciu słów nieznaczących należy użyć count(word, sort = TRUE), aby obliczyć częstość terminów. Jest to podstawa wielu analiz eksploracji tekstu — najczęściej występujące znaczące słowa charakteryzują tematykę dokumentu.

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

Własne słowa nieznaczące

Korpusy z określonej dziedziny często zawierają słowa o dużej częstości, które nie są istotne (np. "patient", "doctor" w notatkach medycznych). Należy utworzyć własny tibble słów nieznaczących i połączyć go z wbudowanym leksykonem za pomocą 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)

Tokenizacja bigramów

Ustawienie token = 'ngrams', n = 2 powoduje tokenizację na kolejne pary słów (bigramy). Bigramy rejestrują wyrażenia takie jak "machine learning" lub "data science", których nie wychwyciłyby pojedyncze słowa, zapewniając bogatszy kontekst.

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

Filtrowanie bigramów pod kątem jakości

Wśród najczęstszych bigramów znajdują się pary słów nieznaczących, takie jak "of the". Należy rozdzielić bigram na dwie kolumny za pomocą tidyr::separate(), odfiltrować wiersze, w których którekolwiek słowo jest słowem nieznaczącym, a następnie ponownie je połączyć, aby uzyskać znaczące pary wyrazów.

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)

Wizualizacja częstości słów

Częstość słów można przedstawić na wykresie słupkowym za pomocą ggplot2. Słupki należy posortować funkcją reorder(word, n), a do uzyskania poziomych etykiet użyć coord_flip(). Jest to jeden z najbardziej komunikatywnych rezultatów eksploracji tekstu.

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

Liczba słów w poszczególnych dokumentach

Jeśli korpus obejmuje wiele dokumentów, należy dodać kolumnę z identyfikatorem dokumentu i grupować dane według doc_id, word, aby obliczyć częstość terminów dla każdego dokumentu. Tak przygotowane dane można bezpośrednio wykorzystać w analizie TF-IDF i modelowaniu tematów.

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

Tokenizacja zdań

Ustawienie token = 'sentences' dzieli tekst na granicach zdań. Tokeny na poziomie zdań są przydatne w analizie sentymentu (ocena każdego zdania), automatycznym podsumowywaniu (wybór reprezentatywnych zdań) i zadaniach odpowiadania na pytania.

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)

Szybkie sprawdzenie

Dokonali Państwo tokenizacji korpusu na słowa za pomocą unnest_tokens() i chcą usunąć często występujące angielskie słowa. Która operacja umożliwia to z użyciem wbudowanego zbioru danych stop_words?

Podsumowanie: tokenizacja i słowa nieznaczące

Najważniejsze informacje:

unnest_tokens(word, text) przekształca surowy tekst w uporządkowany format, w którym każdy wiersz odpowiada jednemu słowu
Domyślnie: zamiana na małe litery i usunięcie interpunkcji; obsługiwane są 'words', 'ngrams', 'sentences'
stop_words to wbudowany tibble zawierający 1149 często używanych angielskich słów z 3 leksykonów
anti_join(tokens, stop_words, by = 'word') usuwa słowa nieznaczące
Za pomocą bind_rows() można dodać własne słowa nieznaczące specyficzne dla dziedziny
count(word, sort = TRUE) oblicza częstość terminów z uporządkowanych tokenów
Bigramy: 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()

Często zadawane pytania

Czy lekcja „Tokenizacja i usuwanie słów pustych” jest bezpłatna?

Tak — pełny tekst „Tokenizacja i usuwanie słów pustych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Tokenizacja i usuwanie słów pustych”?

Dziel tekst na tokeny i filtruj nieinformacyjne słowa za pomocą anti_join(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Tokenizacja i usuwanie słów pustych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do R Academy