Modelos de PNL de última geração de r de r

Introdução

O Transformadores repositório de “Abraçando o rosto” Contém muitos modelos prontos para uso, de ponta, que são diretos para baixar e ajustar o Tensorflow & Keras.

Para esse fim, os usuários geralmente precisam obter:

• O próprio modelo (por exemplo, Bert, Albert, Roberta, GPT-2 e and so on.)
• O objeto tokenizer
• Os pesos do modelo

Neste publish, trabalharemos em uma tarefa clássica de classificação binária e treinaremos nosso conjunto de dados em 3 modelos:

No entanto, os leitores devem saber que é possível trabalhar com transformadores em uma variedade de tarefas de fluxo abaixo, como:

1. extração de recursos
2. Análise de sentimentos
3. Classificação de texto
4. resposta de perguntas
5. resumo
6. tradução e muito mais.

Pré -requisitos

Nosso primeiro trabalho é instalar o transformadores pacote through reticulate.

reticulate::py_install('transformers', pip = TRUE)

Então, como sempre, carregue o padrão ‘Keras’, ‘Tensorflow’> = 2.0 e algumas bibliotecas clássicas de R.

Observe que, se a execução do TensorFlow na GPU, pode -se especificar os seguintes parâmetros para evitar problemas de memória.

physical_devices = tf$config$list_physical_devices('GPU')
tf$config$experimental$set_memory_growth(physical_devices((1)),TRUE)

tf$keras$backend$set_floatx('float32')

Modelo

Já mencionamos que, para treinar dados sobre o modelo específico, os usuários devem baixar o modelo, seu objeto e pesos tokenizadores. Por exemplo, para obter um Roberta Modelo um, deve fazer o seguinte:

# get Tokenizer
transformer$RobertaTokenizer$from_pretrained('roberta-base', do_lower_case=TRUE)

# get Mannequin with weights
transformer$TFRobertaModel$from_pretrained('roberta-base')

Preparação de dados

Um conjunto de dados para classificação binária é fornecido em text2vec pacote. Vamos carregar o conjunto de dados e pegar uma amostra para treinamento rápido do modelo.

Divida nossos dados em 2 partes:

idx_train = pattern.int(nrow(df)*0.8)

prepare = df(idx_train,)
take a look at = df(!idx_train,)

Entrada de dados para keras

Até agora, apenas abordamos a importação de dados e a divisão do teste de trem. Para alimentar a entrada da rede, precisamos transformar nosso texto bruto em índices através do tokenizador importado. E depois adapte o modelo para fazer a classificação binária adicionando uma camada densa com uma única unidade no ultimate.

No entanto, queremos treinar nossos dados para 3 modelos GPT-2, Roberta e Electra. Precisamos escrever um loop para isso.

Nota: Um modelo em geral requer 500-700 MB

# checklist of three fashions
ai_m = checklist(
  c('TFGPT2Model',       'GPT2Tokenizer',       'gpt2'),
   c('TFRobertaModel',    'RobertaTokenizer',    'roberta-base'),
   c('TFElectraModel',    'ElectraTokenizer',    'google/electra-small-generator')
)

# parameters
max_len = 50L
epochs = 2
batch_size = 10

# create a listing for mannequin outcomes
gather_history = checklist()

for (i in 1:size(ai_m)) {
  
  # tokenizer
  tokenizer = glue::glue("transformer${ai_m((i))(2)}$from_pretrained('{ai_m((i))(3)}',
                         do_lower_case=TRUE)") %>% 
    rlang::parse_expr() %>% eval()
  
  # mannequin
  model_ = glue::glue("transformer${ai_m((i))(1)}$from_pretrained('{ai_m((i))(3)}')") %>% 
    rlang::parse_expr() %>% eval()
  
  # inputs
  textual content = checklist()
  # outputs
  label = checklist()
  
  data_prep = perform(information) {
    for (i in 1:nrow(information)) {
      
      txt = tokenizer$encode(information(('comment_text'))(i),max_length = max_len, 
                             truncation=T) %>% 
        t() %>% 
        as.matrix() %>% checklist()
      lbl = information(('goal'))(i) %>% t()
      
      textual content = textual content %>% append(txt)
      label = label %>% append(lbl)
    }
    checklist(do.name(plyr::rbind.fill.matrix,textual content), do.name(plyr::rbind.fill.matrix,label))
  }
  
  train_ = data_prep(prepare)
  test_ = data_prep(take a look at)
  
  # slice dataset
  tf_train = tensor_slices_dataset(checklist(train_((1)),train_((2)))) %>% 
    dataset_batch(batch_size = batch_size, drop_remainder = TRUE) %>% 
    dataset_shuffle(128) %>% dataset_repeat(epochs) %>% 
    dataset_prefetch(tf$information$experimental$AUTOTUNE)
  
  tf_test = tensor_slices_dataset(checklist(test_((1)),test_((2)))) %>% 
    dataset_batch(batch_size = batch_size)
  
  # create an enter layer
  enter = layer_input(form=c(max_len), dtype='int32')
  hidden_mean = tf$reduce_mean(model_(enter)((1)), axis=1L) %>% 
    layer_dense(64,activation = 'relu')
  # create an output layer for binary classification
  output = hidden_mean %>% layer_dense(items=1, activation='sigmoid')
  mannequin = keras_model(inputs=enter, outputs = output)
  
  # compile with AUC rating
  mannequin %>% compile(optimizer= tf$keras$optimizers$Adam(learning_rate=3e-5, epsilon=1e-08, clipnorm=1.0),
                    loss = tf$losses$BinaryCrossentropy(from_logits=F),
                    metrics = tf$metrics$AUC())
  
  print(glue::glue('{ai_m((i))(1)}'))
  # prepare the mannequin
  historical past = mannequin %>% keras::match(tf_train, epochs=epochs, #steps_per_epoch=len/batch_size,
                validation_data=tf_test)
  gather_history((i))<- historical past
  names(gather_history)(i) = ai_m((i))(1)
}

Extrai resultados para ver os benchmarks:

Ambos Roberta e Electra Os modelos mostram algumas melhorias adicionais após 2 épocas de treinamento, o que não pode ser dito de GPT-2. Nesse caso, fica claro que pode ser suficiente para treinar um modelo de ponta, mesmo para uma única época.

Conclusão

Neste publish, mostramos como usar modelos de PNL de última geração de R. para entender como aplicá-los a tarefas mais complexas, é altamente recomendável revisar o Tutorial dos Transformers.

Incentivamos os leitores a experimentar esses modelos e compartilhar seus resultados abaixo na seção de comentários!

Correções

Se você vê erros ou deseja sugerir alterações, por favor criar um problema no repositório de origem.

Reutilizar

Texto e números são licenciados sob atribuição do Artistic Commons CC por 4.0. O código -fonte está disponível em https://github.com/henry090/transformerssalvo indicação em contrário. Os números que foram reutilizados de outras fontes não se enquadram nesta licença e podem ser reconhecidos por uma nota em sua legenda: “Figura de …”.

Citação

Para atribuição, cite este trabalho como

Abdullayev (2020, July 30). Posit AI Weblog: State-of-the-art NLP fashions from R. Retrieved from https://blogs.rstudio.com/tensorflow/posts/2020-07-30-state-of-the-art-nlp-models-from-r/

Citação Bibtex

@misc{abdullayev2020state-of-the-art,
  creator = {Abdullayev, Turgut},
  title = {Posit AI Weblog: State-of-the-art NLP fashions from R},
  url = {https://blogs.rstudio.com/tensorflow/posts/2020-07-30-state-of-the-art-nlp-models-from-r/},
  12 months = {2020}
}