Data Science and Machine Learning - #46 Keras - Classificação de Textos

Nessa aula aprenderemos como utilizar o machine learning através da entrada de textos, como por exemplo avaliações de filmes.

Machine Learning - Avaliação de Filmes

Para treinar o machine learning voltado a textos vamos utilizar o dataset do IMDB.

Importando Módulos e Dataset

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
%matplotlib inline

imdb = keras.datasets.imdb

(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=10000)

Verificando os valores numéricos das palavras

O keras converte cada palavra em um valor numérico. Para averiguar isso, basta rodar os comandos abaixo:

X_train[0][:5]
y_train[0]
len(X_train[0]), len(X_train[1]),len(X_train[2])

Codificando e Decodificando Palavras

Você pode tanto codificar as palavras para numerais como decodificar verificando qual é o texto original:

# Um dicionário mapeando palavras em índices inteiros
word_index = imdb.get_word_index()

# Os primeiros índices são reservados
word_index = {k:(v+3) for k,v in word_index.items()}
word_index["<PAD>"] = 0
word_index["<START>"] = 1
word_index["<UNK>"] = 2  # unknown
word_index["<UNUSED>"] = 3

reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])

def decode_review(text):
    return ' '.join([reverse_word_index.get(i, '?') for i in text])

decode_review(X_train[5])

Processando os Textos

Vamos fazer um processamento dos textos para normalizá-los e colocá-los no mesmo tamanho de 256 caracteres:

X_train = keras.preprocessing.sequence.pad_sequences(X_train,
        value=word_index[""],
        padding='post',
        maxlen=256)

X_test = keras.preprocessing.sequence.pad_sequences(X_test,
       value=word_index[""],
       padding='post',
       maxlen=256)

len(X_train[0]), len(X_train[1]),len(X_train[2])

Preparando os dados

Vamos preparar os nossos dados no Keras:

vocab_size = 10000
model = keras.Sequential()
model.add(keras.layers.Embedding(vocab_size, 16))
model.add(keras.layers.GlobalAveragePooling1D())
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))

model.summary()

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

x_val = X_train[:10000]
partial_x_train = X_train[10000:]

y_val = y_train[:10000]
partial_y_train = y_train[10000:]

Ajustando e Fazendo Predições

Por fim vamos ajustar o texto ao nosso modelo e fazer predições se a sinopse do filme é positiva ou negativa.

model.fit(partial_x_train,
    partial_y_train,
    epochs=40,
    batch_size=512,
    validation_data=(x_val, y_val),
    verbose=1)

newText = "this film is very good and has very good actors"
newText2 = "the film is the worst i wouldn't watch again worst worst worst worst"
newText3 = "this film is horrible"
newText4 = "the film is quite good but i expected more to have high level actors so i would not recommend this film"
newText = newText.split()
newText2 = newText2.split()
newText3 = newText3.split()
newText4 = newText4.split()

list = []
def localizaCode(code):
    return word_index[code]
for i in newText3:
    list.append(localizaCode(i))
list = keras.preprocessing.sequence.pad_sequences([list],
    padding='post',
    maxlen=256)
print(list)

pred = model.predict(list)
np.round(pred[0][0])

Por hoje é só! Sucesso nos códigos e na vida!