python - 不确定我的自动编码器神经网络从 Keras 预测中给我的结果

问题描述

我正在尝试构建一个自动编码器神经网络，用于在单列文本列表中查找异常值。我的输入有 138 行，它们看起来像这样：

amaze_header_2.png
amaze_header.png
circle_shape.xml
disableable_ic_edit_24dp.xml
fab_label_background.xml
fab_shadow_black.9.png
fab_shadow_dark.9.png

我已经使用 Keras 构建了一个自动编码器网络，并使用 python 函数将我的文本输入转换为一个数组，其中每个字符的 ascii 表示，用零填充，因此它们都具有相同的大小。

我的完整代码是这样的：

import sys
from keras import Input, Model
import matplotlib.pyplot as plt
from keras.layers import Dense
import numpy as np
from pprint import pprint
from google.colab import drive

# Monta o arquivo do Google Drive
drive.mount('/content/drive')
with open('/content/drive/My Drive/Colab Notebooks/drawables.txt', 'r') as arquivo:
    dados = arquivo.read().splitlines()

# Define uma função para pegar uma lista e retornar um inteiro com o tamanho do 
# maior elemento
def tamanho_maior_elemento(lista):
  maior = 0
  for elemento in lista:
    tamanho_elemento = len(elemento)
    if tamanho_elemento > maior:
      maior = tamanho_elemento
  return maior

# Define uma função para pegar uma lista e o tamanho do maior elemento e
# retornar uma lista contendo uma outra lista com cada caractere convertido para
# ascii, antes de converter são adicionados zeros a direita para eles ficarem
# com o mesmo tamanho do maior elemento.
def texto_para_ascii(lista, tamanho_maior_elemento):
  #para cada linha
  lista_ascii = list()
  for elemento in lista:
    elemento_ascii_lista = list()
    #coloca zeros do lado da string
    elemento_com_zeros = elemento.ljust(tamanho_maior_elemento, "0")
    for caractere in elemento_com_zeros:
      elemento_ascii_lista.append(ord(caractere))
    lista_ascii.append(elemento_ascii_lista)
  return lista_ascii

def ascii_para_texto(lista):
  #para cada linha
  lista_ascii = list()
  for elemento in lista:
    elemento_ascii_lista = list()
    for caractere in elemento:
      elemento_ascii_lista.append(chr(caractere))
    elemento_ascii_string = "".join(elemento_ascii_lista)
    lista_ascii.append(elemento_ascii_string)
  return lista_ascii

# Pega o tamanho do maior elemento
tamanho_maior_elemento = tamanho_maior_elemento(dados)

# Pega o tamanho da lista
tamanho_lista = len(dados)

# Converte os dados para ascii
dados_ascii = texto_para_ascii(dados, tamanho_maior_elemento)

# Converte a linha de dados em ascii para um array numpy
np_dados_ascii = np.array(dados_ascii)

# Define o tamanho da camada comprimida
tamanho_comprimido = int(tamanho_maior_elemento/5)

# Cria a camada de Input com o tamanho do maior elemento
dados_input = Input(shape=(tamanho_maior_elemento,))

# Cria uma camada escondida com o tamanho da camada comprimida
hidden = Dense(tamanho_comprimido, activation='relu')(dados_input)

# Cria a camada de saida com o tamanho do maior elemento
output = Dense(tamanho_maior_elemento, activation='relu')(hidden)
#resultado = Dense(tamanho_maior_elemento, activation='sigmoid')(output)
resultado = Dense(tamanho_maior_elemento)(output)

# Cria o modelo
autoencoder = Model(input=dados_input, output=resultado)

# Compila o modelo
autoencoder.compile(optimizer='adam', loss='mse')

# Faz o fit com os dados
history = autoencoder.fit(np_dados_ascii, np_dados_ascii, epochs=10)

# Plota o gráfico das epochs
plt.plot(history.history["loss"])
plt.ylabel("Loss")
plt.xlabel("Epoch")
plt.show()

# Pega a saída do predict
predict = autoencoder.predict(np_dados_ascii)

# Pega os índices do array que foram classificados
indices = np.argmax(predict, axis=0)

# Converte a saída do predict de array numpy para array normal
indices_list = indices.tolist()

identificados = list()
for indice in indices_list:
  identificados.append(dados[indice])

pprint(identificados)

我的np.argmax(predict, axis=0)函数返回一个数字列表，其中没有一个大于我的数组大小，所以我假设它们是我输入数组中异常值的位置。

但我非常不确定如何解释预测数据，我的“指数”变量如下所示：

array([116, 116,  74,  74,  97, 115,  34, 116,  39,  39, 116, 116, 115,
       116,  34,  74,  74,  34, 115, 116, 115,  74, 116,  39,  84, 116,
        39,  34,  34,  84, 115, 115,  34,  39,  34, 116, 116,  10])

我做了正确的解释吗？我的意思是，返回的这些数字是什么？它们看起来与我的输入完全不同。所以我假设它们是我输入数据数组上的位置。我对吗？

编辑：如果在脚本结束时我这样做：

print("--------------")
pprint(np_dados_ascii)
print("--------------")
pprint(predict)

我得到以下数据：

--------------
array([[ 97,  98, 111, ...,  48,  48,  48],
       [ 97, 109,  97, ...,  48,  48,  48],
       [ 97, 109,  97, ...,  48,  48,  48],
       ...,
       [115,  97, 102, ...,  48,  48,  48],
       [115, 100,  95, ...,  48,  48,  48],
       [115, 101,  97, ...,  48,  48,  48]])
--------------
array([[86.44533 , 80.48006 , 13.409852, ..., 60.649754, 21.34232 ,
        24.23074 ],
       [98.18514 , 87.98954 , 14.873579, ..., 65.382866, 22.747816,
        23.74556 ],
       [85.682945, 79.46511 , 13.117042, ..., 60.182964, 21.096725,
        22.625275],
       ...,
       [86.989494, 77.36661 , 14.291222, ..., 53.586407, 18.540628,
        26.212025],
       [76.0646  , 70.029236, 11.804929, ..., 52.506832, 18.65119 ,
        21.961123],
       [93.25003 , 82.855354, 15.329873, ..., 56.992035, 19.869513,
        28.3672  ]], dtype=float32)

预测输出是什么意思？如果我的输入是整数数组，我不明白为什么会返回浮点数。

它不应该是一个具有不同形状的数组（在我的结果中，它们是相等的）只包含异常值的 ascii 文本吗？

标签： pythonkerasdeep-learningautoencoder

python - 不确定我的自动编码器神经网络从 Keras 预测中给我的结果

问题描述

解决方案

推荐阅读