Naprawdę szybka wektoryzacja słowa ngram w R

Jest to bardzo interesujący problem, z którym zmagałem się wiele czasu w pakiecie quanteda. Obejmuje trzy aspekty, które skomentuję, chociaż tylko trzeci naprawdę odpowiada na twoje pytanie. Ale pierwsze dwa punkty wyjaśniają, dlaczego skupiłem się tylko na funkcji tworzenia ngram, ponieważ-jak zaznaczasz-to jest miejsce, w którym można poprawić szybkość.

1. tokenizacja. tutaj używasz string::str_split_fixed() na znak spacji, który jest najszybszą, ale nie najlepszą metodą tokenizacji. Zaimplementowaliśmy to prawie dokładnie tak samo jak w quanteda::tokenize(x, what = "fastest word"). Nie jest to najlepsze rozwiązanie, ponieważ stringi mogą wykonywać znacznie mądrzejsze implementacje ograniczników odstępów. (Nawet klasa znaków \\s jest mądrzejsza, ale nieco wolniejsza-jest zaimplementowana jako what = "fasterword"). Twoje pytanie nie dotyczyło tokenizacji, więc ten punkt jest tylko kontekstem.

2. Tabulating the macierz funkcji dokumentu . Tutaj również używamy pakietu macierzy , indeksujemy dokumenty i funkcje (nazywam je funkcjami, a nie terminami) i tworzymy rzadką macierz bezpośrednio, Jak to robisz w powyższym kodzie. Ale twoje użycie match() jest o wiele szybsze niż metody dopasowywania / scalania, których używaliśmy przez dane.tabela . Zamierzam przekodować funkcję quanteda::dfm(), Ponieważ twoja metoda jest bardziej elegancka i szybsza. Naprawdę, bardzo się cieszę, że to zobaczyłem!

3. ngram creation . Tutaj myślę, że mogę rzeczywiście pomóc w zakresie wydajności. Zaimplementujemy to w quanteda poprzez argument do quanteda::tokenize(), zwany grams = c(1), gdzie wartością może być dowolny zbiór liczb całkowitych. Naszym odpowiednikiem dla unigramów i bigramów będzie ngrams = 1:2, na przykład. Możesz sprawdzić kod na https://github.com/kbenoit/quanteda/blob/master/R/tokenize.R , patrz funkcja wewnętrzna ngram(). Odtworzyłem to poniżej i zrobiłem opakowanie, abyśmy mogli bezpośrednio porównać go z Twoim find_ngrams() funkcja.

Kod:

# wrapper
find_ngrams2 <- function(x, ngrams = 1, concatenator = " ") { 
    if (sum(1:length(ngrams)) == sum(ngrams)) {
        result <- lapply(x, ngram, n = length(ngrams), concatenator = concatenator, include.all = TRUE)
    } else {
        result <- lapply(x, function(x) {
            xnew <- c()
            for (n in ngrams) 
                xnew <- c(xnew, ngram(x, n, concatenator = concatenator, include.all = FALSE))
            xnew
        })
    }
    result
}

# does the work
ngram <- function(tokens, n = 2, concatenator = "_", include.all = FALSE) {

    if (length(tokens) < n) 
        return(NULL)

    # start with lower ngrams, or just the specified size if include.all = FALSE
    start <- ifelse(include.all, 
                    1, 
                    ifelse(length(tokens) < n, 1, n))

    # set max size of ngram at max length of tokens
    end <- ifelse(length(tokens) < n, length(tokens), n)

    all_ngrams <- c()
    # outer loop for all ngrams down to 1
    for (width in start:end) {
        new_ngrams <- tokens[1:(length(tokens) - width + 1)]
        # inner loop for ngrams of width > 1
        if (width > 1) {
            for (i in 1:(width - 1)) 
                new_ngrams <- paste(new_ngrams, 
                                    tokens[(i + 1):(length(tokens) - width + 1 + i)], 
                                    sep = concatenator)
        }
        # paste onto previous results and continue
        all_ngrams <- c(all_ngrams, new_ngrams)
    }

    all_ngrams
}

Oto porównanie dla prostego tekstu:

txt <- c("The quick brown fox named Seamus jumps over the lazy dog.", 
         "The dog brings a newspaper from a boy named Seamus.")
tokens <- tokenize(toLower(txt), removePunct = TRUE)
tokens
# [[1]]
# [1] "the"    "quick"  "brown"  "fox"    "named"  "seamus" "jumps"  "over"   "the"    "lazy"   "dog"   
# 
# [[2]]
# [1] "the"       "dog"       "brings"    "a"         "newspaper" "from"      "a"         "boy"       "named"     "seamus"   
# 
# attr(,"class")
# [1] "tokenizedTexts" "list"     

microbenchmark::microbenchmark(zach_ng <- find_ngrams(tokens, 2),
                               ken_ng <- find_ngrams2(tokens, 1:2))
# Unit: microseconds
#                                expr     min       lq     mean   median       uq     max neval
#   zach_ng <- find_ngrams(tokens, 2) 288.823 326.0925 433.5831 360.1815 542.9585 897.469   100
# ken_ng <- find_ngrams2(tokens, 1:2)  74.216  87.5150 130.0471 100.4610 146.3005 464.794   100

str(zach_ng)
# List of 2
# $ : chr [1:21] "the" "quick" "brown" "fox" ...
# $ : chr [1:19] "the" "dog" "brings" "a" ...
str(ken_ng)
# List of 2
# $ : chr [1:21] "the" "quick" "brown" "fox" ...
# $ : chr [1:19] "the" "dog" "brings" "a" ...

Dla Twojego naprawdę dużego, symulowanego tekstu, oto porównanie:

tokens <- stri_split_fixed(sents1, ' ')
zach_ng1_t1 <- system.time(zach_ng1 <- find_ngrams(tokens, 2))
ken_ng1_t1 <- system.time(ken_ng1 <- find_ngrams2(tokens, 1:2))
zach_ng1_t1
#    user  system elapsed 
# 230.176   5.243 246.389 
ken_ng1_t1
#   user  system elapsed 
# 58.264   1.405  62.889 

Już poprawa, byłbym zachwycony, jeśli można to poprawić dalej. Powinienem również być w stanie zaimplementować szybszą metodę dfm() do quanteda , abyś mógł uzyskać to, co chcesz, po prostu poprzez:

dfm(sents1, ngrams = 1:2, what = "fastestword",
    toLower = FALSE, removePunct = FALSE, removeNumbers = FALSE, removeTwitter = TRUE)) 

(to już działa, ale jest wolniejsze niż ogólnie wynik, bo sposób tworzenia końcowego obiektu sparse matrix jest szybszy - ale wkrótce to zmienię.)