Escolhendo entre TensorFlow / Keras, BigQuery ML e AutoML Natural Language para classificação de texto

Comparando a classificação de texto feita de três maneiras no Google Cloud Platform

Lak Lakshmanan Blocked Unblock Seguir Seguindo 4 de janeiro

O Google Cloud Platform oferece três maneiras de realizar o aprendizado de máquina:

  • Keras com um back-end TensorFlow para criar modelos personalizados de aprendizagem profunda treinados no Cloud ML Engine
  • BigQuery ML para construir modelos lineares em dados estruturados usando apenas SQL
  • Auto ML para treinar modelos de aprendizagem profunda de última geração em seus dados sem escrever nenhum código

Escolha entre eles com base no seu conjunto de habilidades, quão importante é a precisão adicional e quanto tempo / esforço você está disposto a dedicar ao problema. Use o BigQuery ML para experimentações rápidas e aprendizado de máquina fácil e de baixo custo. Depois de identificar um problema de ML viável usando o BQML, use o Auto ML para modelos de última geração livres de código. Crie manualmente seus próprios modelos personalizados apenas para problemas em que você tenha muitos dados e tempo / esforço suficientes para dedicar.

Escolher o método ML que é certo para você depende de quanto tempo e esforço você está disposto a investir, que tipo de precisão você precisa e qual é o seu conhecimento.

Neste artigo, vou comparar as três abordagens em um problema de classificação de texto para que você possa ver por que estou recomendando o que estou recomendando.

1. CNN + Incorporação + Rejeição em Keras

Eu explico o problema e a solução de aprendizado profundo em detalhes em outros lugares, então esta seção será muito breve.

A tarefa é que, dado o título de um artigo, eu quero ser capaz de identificar onde ele foi publicado. O conjunto de dados de treinamento vem de artigos publicados no Hacker News (há um conjunto de dados públicos desses no BigQuery). Por exemplo, aqui estão alguns dos títulos cuja fonte é o GitHub:

Conjunto de dados de treinamento

O código do modelo para criar um modelo Keras que usa uma camada de incorporação de palavras, camadas convolucionais e abandono:

 model = models.Sequential () 
num_features = min (len (word_index) + 1, TOP_K)
model.add (Incorporação (input_dim = num_features,
output_dim = embedding_dim,
input_length = MAX_SEQUENCE_LENGTH))
 model.add (Dropout (rate = dropout_rate)) 
model.add (Conv1D (filtros = filtros,
kernel_size = kernel_size,
ativação = 'relu',
bias_initializer = 'random_uniform',
padding = 'same'))
 model.add (MaxPooling1D (pool_size = pool_size)) 
model.add (Conv1D (filtros = filtros * 2,
kernel_size = kernel_size,
ativação = 'relu',
bias_initializer = 'random_uniform',
padding = 'same'))
model.add (GlobalAveragePooling1D ())
model.add (Dropout (rate = dropout_rate))
model.add (denso (len (CLASSES), ativação = 'softmax'))
 # Compile model with learning parameters. 
optimizer = tf.keras.optimizers.Adam (lr = learning_rate)
model.compile (optimizer = optimizer, perda = 'sparse_categorical_crossentropy', metrics = ['acc'])
estimator = tf.keras.estimator.model_to_estimator (keras_model = modelo, model_dir = model_dir, config = config)

Isso é então treinado no Cloud ML Engine como mostrado neste notebook Jupyter :

 Os trabalhos do gcloud ml-engine apresentam treinamento $ JOBNAME  
--region = $ REGION
--module-name = trainer.task
--package-path = $ {PWD} / txtclsmodel / trainer
--job-dir = $ OUTDIR
--scale-tier = BASIC_GPU
--runtime-version = $ TFVERSION
-
--output_dir = $ OUTDIR
--train_data_path = gs: // $ {BUCKET} /txtcls/train.tsv
--eval_data_path = gs: // $ {BUCKET} /txtcls/eval.tsv
--num_epochs = 5

Levei alguns dias para desenvolver o modelo original do TensorFlow, meu colega vijaykr um dia para modificá-lo para usar o Keras, e talvez um dia para treiná-lo e resolvê-lo.

Temos cerca de 80% de precisão. Para fazer melhor, provavelmente precisaríamos de muito mais dados (92k exemplos são insuficientes para obter os benefícios de usar um modelo de aprendizado detalhado personalizado) e talvez incorporar mais pré-processamento (como remover palavras de parada, palavras contidas, usar uma incorporação reutilizável) etc).

2. BigQuery ML para classificação de texto

Ao usar o BigQuery ML, redes neurais convolucionais, incorporações, etc. são (ainda não de qualquer maneira) uma opção, então eu usei um modelo linear em um saco de palavras. O objetivo do BigQuery ML é fornecer uma maneira rápida e conveniente de construir modelos ML em dados estruturados e semiestruturados.

Dividindo os títulos palavra por palavra e treinando um modelo de regressão logística (ou seja, um classificador linear) nas primeiras 5 palavras do título (usar mais palavras não ajuda muito):

 #standardsql 
CREATE OR REPLACE MODEL advdata.txtclass
OPTIONS (model_type = 'logistic_reg', input_label_cols = ['fonte'])
COMO
 WITH extraído AS ( 
Fonte SELECT, REGEXP_REPLACE (LOWER (REGEXP_REPLACE (título, '[^ a-zA-Z0-9 $ .-]', '')), "", "") COMO título FROM
(SELECIONAR
ARRAY_REVERSE (SPLIT (REGEXP_EXTRACT (url, '. *: // (. [^ /] +) /'), '.')) [OFFSET (1)] como origem,
título
DE
`bigquery-public-data.hacker_news.stories
ONDE
REGEXP_CONTAINS (REGEXP_EXTRACT (url, '. *: // (. [^ /] +) /'), '.Com $')
AND LENGTH (título)> 10
)
)
 , ds AS ( 
SELECIONAR ARRAY_CONCAT (SPLIT (title, ""), ['NULL', 'NULL', 'NULL', 'NULL', 'NULL']) Como palavras, source FROM extraído
WHERE (fonte = 'github' OR source = 'nytimes' OR source = 'techcrunch')
)
 SELECIONAR 
fonte,
palavras [OFFSET (0)] como word1,
palavras [OFFSET (1)] AS word2,
palavras [OFFSET (2)] como word3,
palavras [OFFSET (3)] como word4,
palavras [OFFSET (4)] AS word5
FROM ds

Isso foi rápido. A consulta SQL acima é a enchilada completa. Não há mais nada para isso. O treinamento do modelo em si levou apenas alguns minutos. Eu tenho 78% de precisão, o que compara bastante favoravelmente aos 80% que recebi com o modelo personalizado Keras CNN.

Depois de treinadas, as previsões em lote usando o BigQuery são fáceis:

 SELECT * FROM ML.PREDICT (MODEL advdata.txtclass, ( 
SELECT 'government' como word1, 'shutdown' como word2, 'sai' como word3, 'workers' como word4, 'enrolando' como word5)
)

O BigQuery ML identifica o New York Times como a fonte mais provável de um artigo que começa com as palavras "A paralisação do governo deixa os trabalhadores em estado de choque".

As previsões on-line usando o BigQuery podem ser realizadas exportando os pesos em um aplicativo da web.

3. AutoML

A terceira opção que experimentei é a opção livre de código que, no entanto, usa modelos e técnicas de última geração. Como esse é um problema de classificação de texto, a abordagem de ML Automático a ser usada é a Linguagem Natural do ML Auto.

3a. Lançar o idioma natural AutoML

O primeiro passo é lançar o Auto ML Natural Language no console da web do GCP:

Lançar o AutoML Natural Language no console da web do GCP

Siga os prompts e um bloco será criado para conter o conjunto de dados que você usará para treinar o modelo.

3b. Crie um arquivo CSV e disponibilize-o no Google Cloud Storage

Onde o BigQuery ML exige que você conheça o SQL, o AutoML exige apenas que você crie um conjunto de dados em um dos formatos que a ferramenta entende. A ferramenta entende os arquivos CSV organizados da seguinte maneira:

texto, etiqueta

O texto em si pode ser um URL para um arquivo que contém o texto real (isso é útil se você tiver texto de várias linhas, como revisões ou documentos inteiros) ou pode ser o item de texto simples em si. Se você está fornecendo a string de item de texto diretamente, você precisa colocá-la entre aspas.

Assim, nossa primeira etapa é exportar um arquivo CSV do BigQuery no formato correto. Esta foi minha consulta:

 WITH extraído AS ( 
Fonte SELECT, LOWER (REGEXP_REPLACE (título, '[^ a-zA-Z0-9 $ .-]', '')) COMO título FROM
(SELECIONAR
ARRAY_REVERSE (SPLIT (REGEXP_EXTRACT (url, '. *: // (. [^ /] +) /'), '.')) [OFFSET (1)] como origem,
título
DE
`bigquery-public-data.hacker_news.stories
ONDE
REGEXP_CONTAINS (REGEXP_EXTRACT (url, '. *: // (. [^ /] +) /'), '.Com $')
AND LENGTH (título)> 10
)
)
 SELECT CONCAT ('", título,'" ') como título, origem FROM extraído 
WHERE (fonte = 'github' OR source = 'nytimes' OR source = 'techcrunch') E COMPRIMENTO (título)> 0

Que produz o seguinte conjunto de dados:

Conjunto de dados para AutoML

Note que eu retirei pontuação e caracteres especiais (AutoML pode acomodar essas coisas, mas eu já tinha o código de limpeza da seção do BigQuery, então acabei continuando a usá-lo). Como vou colocar o item de texto diretamente no CSV (em vez de colocá-lo em arquivos separados no Cloud Storage), coloquei aspas nele.

Salvei o resultado da consulta como uma tabela usando a interface do BigQuery:

Salvar os resultados da consulta como uma tabela

e, em seguida, exportou a tabela para um arquivo CSV:

Exportar os dados da tabela para o bucket ML Auto

3c. Criar conjunto de dados ML automático

O próximo passo é usar a interface do usuário do ML automático para criar um conjunto de dados do arquivo CSV no Cloud Storage:

Criar um conjunto de dados do arquivo CSV no Cloud Storage

O conjunto de dados leva cerca de 20 minutos para ser ingerido. No final, temos uma tela cheia de itens de texto:

O conjunto de dados após o carregamento

O atual limite automático de ML é de 100k linhas , portanto, nosso conjunto de dados de 92k está definitivamente forçando alguns limites. Um conjunto de dados menor será ingerido mais rapidamente.

Por que temos um rótulo chamado "fonte" com apenas um exemplo? O arquivo CSV tinha uma linha de cabeçalho (fonte, título) e isso também foi ingerido! Felizmente, AutoML nos permite editar os itens de texto na própria GUI. Então, eu apaguei o rótulo extra e seu texto correspondente.

3d. Trem

O treinamento é tão fácil quanto clicar em um botão.

O ML Auto, em seguida, prossegue para tentar várias inserções e várias arquiteturas e faz o ajuste de hyperparameter para obter uma boa solução para o problema.

Demora 5 horas.

3e. Avaliação

Uma vez que o modelo é treinado, obtemos várias estatísticas de avaliação: precisão, recuperação, curva de AUC, etc. Mas também obtemos a matriz de confusão real a partir da qual podemos calcular qualquer outra coisa que desejemos:

A precisão geral é de cerca de 86% – maior até do que o nosso modelo personalizado Keras CNN. Por quê? Porque o Auto ML é capaz de tirar proveito do aprendizado de transferência de modelos construídos em conjuntos de dados do Google sobre o uso da linguagem, ou seja, inclui dados que não temos disponíveis para o nosso modelo Keras. Além disso, devido à disponibilidade de todos os dados para transferir, a arquitetura do modelo pode ser mais complexa (leia-se: mais profundo).

3f. Predição

O modelo AutoML treinado já está implantado e disponível para previsão. Podemos enviar uma solicitação e recuperar a origem prevista do artigo:

Previsões do ML Auto

Observe que o modelo é muito mais confiável do que o modelo BQML (embora ambos tenham dado a mesma resposta correta), uma confiança impulsionada pelo fato de que este modelo Auto ML foi treinado em mais dados e é construído especificamente para problemas de classificação de texto.

Eu tentei outro título de artigo de manchetes de hoje e o modelo pregado como sendo do TechCrunch:

Identifica corretamente o título como sendo de um artigo do TechCrunch.

Resumo

Embora este artigo seja principalmente sobre classificação de texto, as conclusões gerais e conselhos são transferidos para a maioria dos problemas de ML:

  • Use o BigQuery ML para aprendizado de máquina fácil e de baixo custo e experimentos rápidos para ver se o ML é viável em seus dados. Às vezes, a precisão que você obtém com o BQML é suficiente e você simplesmente pára aqui.
  • Depois de identificar um problema de ML viável usando o BQML, use o Auto ML para modelos de última geração livres de código. A classificação de texto, por exemplo, é um campo muito especializado com entradas de alta dimensão. Assim, você pode fazer melhor com uma solução personalizada (ou seja, Auto ML Natural Language) do que com uma abordagem de dados estruturados que use apenas palavras-chave.
  • Crie manualmente seus próprios modelos personalizados apenas para problemas em que você tenha muitos dados e tempo / esforço suficientes para dedicar. Use AutoML como referência. Se, você não pode bater ML Auto após algum esforço razoável, pare de perder tempo. Basta ir com o Auto ML.

¹ Há algumas outras maneiras de aprender máquina no GCP. Você pode fazer xgboost ou scikit-learn no ML Engine. A VM Deep Learning suporta o PyTorch. O Spark ML funciona bem no Cloud Dataproc. E, claro, você pode usar o Google Compute Engine ou o Google Kubernetes Engine e instalar qualquer estrutura ML desejada. Mas neste artigo, vou me concentrar nesses três.

Texto original em inglês.