[CLS] the [MASK] has blue spots [SEP] it rolls [MASK] the parking lot [SEP]Com os metadados adicionados aos seus pontos de dados, o LM mascarado está pronto para funcionar.
Quando terminar de prever as palavras, o BERT aproveitará a previsão da próxima frase. Isso analisa a relação entre duas frases. Isso é feito para entender melhor o contexto de todo o conjunto de dados, usando um par de frases e prevendo se a segunda frase é a próxima, com base no texto original.
Para que a previsão da próxima frase funcione na técnica BERT, a segunda frase é enviada através do Modelo baseado em transformador.
Existem quatro versões pré-treinadas diferentes do BERT, dependendo da escala de dados com a qual você está trabalhando. Você pode aprender mais sobre eles aqui: https://github.com/google-research/bert#bert
A desvantagem dessa abordagem é que a função de perda considera apenas as previsões de palavras mascaradas e não as previsões das outras. Isso significa que a técnica BERT converge mais lentamente que as outras técnicas da direita para a esquerda ou da esquerda para a direita.
O BERT pode ser aplicado a qualquer problema de PNL que você possa imaginar, incluindo previsão de intenção, aplicativos de resposta a perguntas e classificação de texto.
Exemplo de código
Como configurar
Agora vamos ver um exemplo de BERT em ação. A primeira coisa que você precisa fazer é clonar o repo Bert.
git clone https://github.com/google-research/bert.gitAgora você precisa fazer o download dos arquivos de modelo BERT pré-treinados do Página BERT GitHub. No restante deste tutorial, vou me referir ao diretório deste repositório como o diretório raiz.
Esses arquivos fornecem os hiperparâmetros, pesos e outras coisas necessárias com as informações que Bert aprendeu durante o pré-treinamento. Eu vou estar usando o BERT-Base, modelo não revestido, mas você encontrará várias outras opções em diferentes idiomas na página do GitHub.
Alguns motivos pelos quais você escolheria o modelo BERT-Base, Uncased é se não tiver acesso a um Google TPU; nesse caso, você normalmente escolheria um modelo Base.
Se você acha que a caixa do texto que está tentando analisar faz distinção entre maiúsculas e minúsculas (a caixa do texto dá um significado contextual real), você deve usar um modelo Cased.
Se a caixa não for importante ou você ainda não tiver certeza, um modelo não revestido seria uma opção válida.
Trabalharemos com algumas avaliações do Yelp como nosso conjunto de dados. Lembre-se, o BERT espera os dados em um determinado formato usando aqueles casamentos de token e outros. Precisamos adicioná-los a um arquivo .tsv. Este arquivo será semelhante a um arquivo .csv, mas terá quatro colunas e nenhuma linha de cabeçalho.
Aqui está a aparência das quatro colunas.
- Coluna 0: ID da linha
- Coluna 1: Rótulo da linha (precisa ser um número inteiro)
- Coluna 2: uma coluna da mesma letra para todas as linhas (não é usada para nada, mas o BERT espera isso)
- Coluna 3: O texto que queremos classificar
Você precisará criar uma pasta chamada data no diretório em que clonou o BERT e adicionar três arquivos lá: train.tsv, dev.tsv, test.tsv.
No train.tsv e dev.tsv arquivos, teremos as quatro colunas sobre as quais falamos anteriormente. No test.tsv arquivo, teremos apenas o ID da linha e o texto que queremos classificar como colunas. Esses serão os arquivos de dados que usamos para treinar e testar nosso modelo.
Preparando os dados
Primeiro, precisamos obter os dados com os quais trabalharemos. Você pode fazer o download das avaliações do Yelp aqui: https://course.fast.ai/datasets#nlp Ele estará na seção PNL e você desejará a versão Polarity.
O motivo de trabalharmos com esta versão é porque os dados já possuem polaridade, o que significa que já possuem um sentimento associado a eles. Salve este arquivo no diretório de dados.
Agora estamos prontos para começar a escrever o código. Crie um novo arquivo no diretório raiz chamado pre_processing.py e adicione o seguinte código.
import pandas as pd
# this is to extract the data from that .tgz file
import tarfile
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
# get all of the data out of that .tgz
yelp_reviews = tarfile.open('data/yelp_review_polarity_csv.tgz')
yelp_reviews.extractall('data')
yelp_reviews.close()
# check out what the data looks like before you get started
# look at the training data set
train_df = pd.read_csv('data/yelp_review_polarity_csv/train.csv', header=None)
print(train_df.head())
# look at the test data set
test_df = pd.read_csv('data/yelp_review_polarity_csv/test.csv', header=None)
print(test_df.head())
Neste código, importamos alguns pacotes Python e descompactamos os dados para ver como eles são. Você notará que os valores associados às críticas são 1 e 2, sendo 1 uma crítica ruim e 2 uma boa crítica. Precisamos converter esses valores em mais rótulos padrão, então 0 e 1. Você pode fazer isso com o código a seguir.
train_df[0] = (train_df[0] == 2).astype(int)
test_df[0] = (test_df[0] == 2).astype(int)Sempre que você faz atualizações nos seus dados, é sempre importante verificar se tudo deu certo. Então, faremos isso com os seguintes comandos.
print(train_df.head())
print(test_df.head())Quando você perceber que seus valores de polaridade mudaram para o que você esperava. Agora que os dados devem ter 1s e 0s.
Como limpamos os dados iniciais, é hora de preparar as coisas para o BERT. Teremos que ajustar nossos dados aos formatos de coluna de que falamos anteriormente. Vamos começar com os dados do treinamento.
Os dados de treinamento terão todas as quatro colunas: identificação da linha, rótulo da linha, letra única, texto que queremos classificar.
O BERT espera dois arquivos para treinamento chamados trem e dev. Tornaremos esses arquivos dividindo o arquivo de trem inicial em dois arquivos depois de formatar nossos dados com os seguintes comandos.
bert_df = pd.DataFrame({
'id': range(len(train_df)),
'label': train_df[0],
'alpha': ['q']*train_df.shape[0],
'text': train_df[1].replace(r'n', ' ', regex=True)
})
train_bert_df, dev_bert_df = train_test_split(bert_df, test_size=0.01)Com o bert_df variável, formatamos os dados para serem o que o BERT espera. Você pode escolher qualquer outra letra para o valor alfa, se quiser. o train_test_split O método que importamos no início trata da divisão dos dados de treinamento nos dois arquivos que precisamos.
Veja como os dados foram formatados com este comando.
print(train_bert_df.head())Agora precisamos formatar os dados de teste. Isso parecerá diferente de como lidamos com os dados de treinamento. O BERT espera apenas duas colunas para os dados de teste: ID da linha, texto que queremos classificar. Não precisamos fazer mais nada com os dados de teste, uma vez que os tivermos neste formato e faremos isso com o seguinte comando.
test_bert_df = pd.DataFrame({
'id': range(len(test_df)),
'text': test_df[1].replace(r'n', ' ', regex=True)
})É semelhante ao que fizemos com os dados de treinamento, apenas sem duas das colunas. Dê uma olhada nos dados de teste recém-formatados.
test_bert_df.head()Se tudo parecer bom, você pode salvar essas variáveis, pois os arquivos .tsv com os quais o BERT trabalhará.
train_bert_df.to_csv('data/train.tsv', sep='t', index=False, header=False)
dev_bert_df.to_csv('data/dev.tsv', sep='t', index=False, header=False)
test_bert_df.to_csv('data/test.tsv', sep='t', index=False, header=False)Treinando o modelo
Uma observação rápida antes de começarmos a treinar o modelo: o BERT pode consumir muitos recursos em laptops. Pode causar erros de memória porque não há RAM suficiente ou outro hardware não é poderoso o suficiente. Você pode tentar fazer o training_batch_size menor, mas isso tornará o treinamento do modelo muito lento.
Adicione uma pasta ao diretório raiz chamado model_output. É aí que nosso modelo será salvo após o término do treinamento. Agora abra um terminal e vá para o diretório raiz deste projeto. Quando estiver no diretório certo, execute o seguinte comando e ele começará a treinar seu modelo.
python run_classifier.py --task_name=cola --do_train=true --do_eval=true --data_dir=./data/ --vocab_file=./uncased_L-12_H-768_A-12/vocab.txt --bert_config_file=./uncased_L-12_H-768_A-12/bert_config.json --init_checkpoint=./uncased_L-12_H768_A-12/bert_model.ckpt.index --max_seq_length=128 --train_batch_size=32 --learning_rate=2e-5 --num_train_epochs=3.0 --output_dir=./model_output --do_lower_case=FalseVocê deve ver alguma saída rolando pelo seu terminal. Quando isso terminar, você terá um modelo treinado e pronto para fazer previsões!
Fazendo uma predicação
Se você der uma olhada no model_output diretório, você notará que há um monte de model.ckpt arquivos. Esses arquivos têm os pesos para o modelo treinado em diferentes pontos durante o treinamento, portanto, você deseja encontrar aquele com o número mais alto. Esse será o modelo final treinado que você deseja usar.
Agora vamos correr run_classifier.py novamente com opções ligeiramente diferentes. Em particular, mudaremos o init_checkpoint valor ao ponto de verificação mais alto do modelo e definindo um novo –do_predict valor para true. Aqui está o comando que você precisa executar no seu terminal.
python run_classifier.py --task_name=cola --do_predict=true --data_dir=./data --vocab_file=./uncased_L-12_H-768-A-12/bert_config.json --init_checkpoint=./model_output/model.ckpt-<highest checkpoint number> --max_seq_length=128 --output_dir=./model_outputQuando o comando terminar de executar, você verá um novo arquivo chamado test_results.tsv. Isso terá seus resultados previstos com base no modelo que você treinou!
Você acabou de usar o BERT para analisar alguns dados reais e espero que tudo isso faça sentido.
Outros pensamentos
Eu senti que era necessário passar pelo processo de limpeza de dados aqui para o caso de alguém não ter passado por isso antes. Às vezes, o aprendizado de máquina parece mágico, mas está realmente demorando para colocar seus dados na condição certa para treinar com um algoritmo.
O BERT ainda é relativamente novo desde que foi lançado em 2018, mas até agora provou ser mais preciso do que os modelos existentes, mesmo que seja mais lento.