germeval03-sent-wordvec-rf-plain

textmining

datawrangling

germeval

prediction

tidymodels

sentiment

string

random-forest

tune

Published

December 3, 2023

Aufgabe

Erstellen Sie ein prädiktives Modell für Textdaten. Nutzen Sie Sentiments und TextFeatures im Rahmen von Feature-Engineering. Nutzen Sie außerdem deutsche Word-Vektoren für das Feature-Engineering.

Als Lernalgorithmus verwenden Sie XGB.

Preppen und Backen Sie das Rezept, aber führen Sie die Pipelien mit dem gebackenen Datensatz und einem “Plain-Rezept” durch.

Daten

Verwenden Sie die GermEval-2018-Daten.

Die Daten sind unter CC-BY-4.0 lizensiert. Author: Wiegand, Michael (Spoken Language Systems, Saarland University (2010-2018), Leibniz Institute for the German Language (since 2019)),

Die Daten sind auch über das R-Paket PradaData zu beziehen.

library(tidyverse)
data("germeval_train", package = "pradadata")
data("germeval_test", package = "pradadata")

AV und UV

Die AV lautet c1. Die (einzige) UV lautet: text.

Hinweise

Orientieren Sie sich im Übrigen an den allgemeinen Hinweisen des Datenwerks.
Nutzen Sie Tidymodels.
Nutzen Sie das sentiws Lexikon.
❗ Achten Sie darauf, die Variable c2 zu entfernen bzw. nicht zu verwenden.

Lösung

Setup

d_train <-
  germeval_train |> 
  select(id, c1, text)

library(tictoc)
library(tidymodels)
library(syuzhet)
library(beepr)
library(lobstr)  # object size
library(visdat)  # Fingerprint/footprint of dataset (CSV)
data("sentiws", package = "pradadata")

Eine Vorlage für ein Tidymodels-Pipeline findet sich hier.

Learner/Modell: RF

mod <-
  rand_forest(mode = "classification",
           mtry = tune(), 
           min_n = tune()
  )

Gebackenen Datensatz als neue Grundlage

Wir importieren den schon an anderer Stelle aufbereiteten Datensatz. Das hat den Vorteil (hoffentlich), das die Datenvolumina viel kleiner sind. Die Arbeit des Feature Engineering wurde uns schon abgenommen.

d_train <-
  read_csv("https://raw.githubusercontent.com/sebastiansauer/Datenwerk2/main/data/germeval/germeval_train_recipe_wordvec_senti.csv")

vis_dat(d_train) +
  # remove axis labels:
  theme(axis.text.x=element_blank(),
        axis.ticks.x=element_blank() 
        )

d_test_baked <- read_csv("https://raw.githubusercontent.com/sebastiansauer/Datenwerk2/main/data/germeval/germeval_test_recipe_wordvec_senti.csv")

Plain-Rezept

rec <- 
  recipe(c1 ~ ., data = d_train)

Neuer Workflow mit plainem Rezept

wf <-
  workflow() |> 
  add_recipe(rec) |> 
  add_model(mod)

Parallelisierung über mehrere Kerne

library(parallel)
all_cores <- detectCores(logical = FALSE)

library(doFuture)
registerDoFuture()
cl <- makeCluster(3)
plan(cluster, workers = cl)

Achtung: Viele Kerne brauchen auch viel Speicher.

Tune/Resample/Fit

tic()
fit_wordvec_senti_rf <-
  tune_grid(
    wf,
    grid = 10,
    resamples = vfold_cv(d_train, v = 5))
toc()

1556.058 sec elapsed

beep()

Moderate Größe:

obj_size(fit_wordvec_senti_rf)

5.05 MB

Get best performance

autoplot(fit_wordvec_senti_rf)

show_best(fit_wordvec_senti_rf)

# A tibble: 5 × 8
   mtry min_n .metric .estimator  mean     n std_err .config              
  <int> <int> <chr>   <chr>      <dbl> <int>   <dbl> <chr>                
1     8    26 roc_auc binary     0.792     5 0.00890 Preprocessor1_Model09
2    19    33 roc_auc binary     0.782     5 0.00851 Preprocessor1_Model08
3    32     8 roc_auc binary     0.777     5 0.00783 Preprocessor1_Model03
4    41    17 roc_auc binary     0.773     5 0.00715 Preprocessor1_Model10
5    74     5 roc_auc binary     0.768     5 0.00626 Preprocessor1_Model02

best_params <- select_best(fit_wordvec_senti_rf)

Finalisieren

best_params <- select_best(fit_wordvec_senti_rf)
tic()
wf_finalized <- finalize_workflow(wf, best_params)
lastfit_rf <- fit(wf_finalized, data = d_train)
toc()

13.055 sec elapsed

Test-Set-Güte

tic()
preds <-
  predict(lastfit_rf, new_data = d_test_baked)
toc()

0.338 sec elapsed

d_test <-
  germeval_test |> 
  bind_cols(preds) |> 
  mutate(c1 = as.factor(c1))

my_metrics <- metric_set(accuracy, f_meas)
my_metrics(d_test,
           truth = c1,
           estimate = .pred_class)

# A tibble: 2 × 3
  .metric  .estimator .estimate
  <chr>    <chr>          <dbl>
1 accuracy binary         0.707
2 f_meas   binary         0.303

Fazit

Verzichtet man auf ein Rezept mit viel Datenvolumen (Wordvektoren blähen das Rezept mächtig auf), so wird das Fitten schlanker und schneller. Schneller auch deshalb, weil ggf. kein Swapping zwischen Speicher und Festplatte mehr nötig ist.

--- expoints: 1 extype: string exsolution: NA categories: - textmining - datawrangling - datawrangling - germeval - prediction - tidymodels - sentiment - string - random-forest - tune date: '2023-12-03' title: germeval03-sent-wordvec-rf-plain draft: false eval: true --- ```{r global-knitr-options, include=FALSE, message=FALSE} knitr::opts_chunk$set(fig.pos = 'H', fig.asp = 0.618, fig.width = 4, fig.cap = "", fig.path = "", echo = TRUE, # ECHO IS FALSE!!! message = FALSE, warning = FALSE, fig.show = "hold") options(max.print = 10) options(rstudio.help.showDataPreview = FALSE) ``` # Aufgabe Erstellen Sie ein prädiktives Modell für Textdaten. Nutzen Sie Sentiments und TextFeatures im Rahmen von Feature-Engineering. Nutzen Sie außerdem *deutsche Word-Vektoren* für das Feature-Engineering. Als Lernalgorithmus verwenden Sie XGB. Preppen und Backen Sie das Rezept, aber führen Sie die Pipelien mit dem gebackenen Datensatz und einem "Plain-Rezept" durch. ## Daten Verwenden Sie die [GermEval-2018-Daten](https://heidata.uni-heidelberg.de/dataset.xhtml?persistentId=doi:10.11588/data/0B5VML). Die Daten sind unter CC-BY-4.0 lizensiert. Author: Wiegand, Michael (Spoken Language Systems, Saarland University (2010-2018), Leibniz Institute for the German Language (since 2019)), Die Daten sind auch über das R-Paket [PradaData](https://github.com/sebastiansauer/pradadata/tree/master/data-raw/GermEval-2018-Data-master) zu beziehen. ```{r data} library(tidyverse) data("germeval_train", package = "pradadata") data("germeval_test", package = "pradadata") ``` ## AV und UV Die AV lautet `c1`. Die (einzige) UV lautet: `text`. ## Hinweise - Orientieren Sie sich im Übrigen an den [allgemeinen Hinweisen des Datenwerks](https://datenwerk.netlify.app/hinweise). - Nutzen Sie Tidymodels. - Nutzen Sie das `sentiws` Lexikon. - ❗ Achten Sie darauf, die Variable `c2` zu entfernen bzw. nicht zu verwenden. # Lösung ## Setup ```{r d-train} d_train <- germeval_train |> select(id, c1, text) ``` ```{r libs} library(tictoc) library(tidymodels) library(syuzhet) library(beepr) library(lobstr) # object size library(visdat) # Fingerprint/footprint of dataset (CSV) data("sentiws", package = "pradadata") ``` Eine [Vorlage für ein Tidymodels-Pipeline findet sich hier](https://datenwerk.netlify.app/posts/tidymodels-vorlage2/tidymodels-vorlage2.html). ## Learner/Modell: RF ```{r} mod <- rand_forest(mode = "classification", mtry = tune(), min_n = tune() ) ``` ## Gebackenen Datensatz als neue Grundlage Wir importieren den schon an anderer Stelle aufbereiteten Datensatz. Das hat den Vorteil (hoffentlich), das die Datenvolumina viel kleiner sind. Die Arbeit des Feature Engineering wurde uns schon abgenommen. ```{r import-train-data} d_train <- read_csv("https://raw.githubusercontent.com/sebastiansauer/Datenwerk2/main/data/germeval/germeval_train_recipe_wordvec_senti.csv") ``` ```{r vis-dat} vis_dat(d_train) + # remove axis labels: theme(axis.text.x=element_blank(), axis.ticks.x=element_blank() ) ``` ```{r} d_test_baked <- read_csv("https://raw.githubusercontent.com/sebastiansauer/Datenwerk2/main/data/germeval/germeval_test_recipe_wordvec_senti.csv") ``` ## Plain-Rezept ```{r} rec <- recipe(c1 ~ ., data = d_train) ``` ## Neuer Workflow mit plainem Rezept ```{r wf-new} wf <- workflow() |> add_recipe(rec) |> add_model(mod) ``` ## Parallelisierung über mehrere Kerne ```{r} library(parallel) all_cores <- detectCores(logical = FALSE) library(doFuture) registerDoFuture() cl <- makeCluster(3) plan(cluster, workers = cl) ``` Achtung: Viele Kerne brauchen auch viel Speicher. ## Tune/Resample/Fit ```{r fit} tic() fit_wordvec_senti_rf <- tune_grid( wf, grid = 10, resamples = vfold_cv(d_train, v = 5)) toc() beep() ``` Moderate Größe: ```{r} obj_size(fit_wordvec_senti_rf) ``` ## Get best performance ```{r} autoplot(fit_wordvec_senti_rf) ``` ```{r show-best} show_best(fit_wordvec_senti_rf) ``` ```{r select-best} best_params <- select_best(fit_wordvec_senti_rf) ``` ## Finalisieren ```{r finalize-wf} best_params <- select_best(fit_wordvec_senti_rf) tic() wf_finalized <- finalize_workflow(wf, best_params) lastfit_rf <- fit(wf_finalized, data = d_train) toc() ``` ## Test-Set-Güte ```{r predict} tic() preds <- predict(lastfit_rf, new_data = d_test_baked) toc() ``` ```{r bind-cols-metrics} d_test <- germeval_test |> bind_cols(preds) |> mutate(c1 = as.factor(c1)) my_metrics <- metric_set(accuracy, f_meas) my_metrics(d_test, truth = c1, estimate = .pred_class) ``` ## Fazit Verzichtet man auf ein Rezept mit viel Datenvolumen (Wordvektoren blähen das Rezept mächtig auf), so wird das Fitten schlanker und schneller. Schneller auch deshalb, weil ggf. kein Swapping zwischen Speicher und Festplatte mehr nötig ist.