不确定我的自动编码器神经网络从Keras predi得到的结果

Question

我正在尝试建立一个自动编码器神经网络，用于在单列文本列表中查找异常值。我的输入有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文本吗？你知道吗

Answer 1

自动编码器是一种神经网络，用于将高维输入映射到低维表示。自动编码器的体系结构非常容易理解和实现。你知道吗

This article以一种简单的方式解释它们的作用以及您应该如何解释数据。你知道吗

对于您的具体情况，首先，我将尝试不同的输入表示法，将每个单词分割在任何'.'或'.'之后，并使用Keras嵌入层将其编码为向量：here a tutorial on how to use Embedding Layers

然后，您真正想要的是查看中间隐藏层的输出，即将输入编码到较低维空间的输出。从这个低维空间，你可以训练一个分类器来检测离群点，如果你有基本的真相，或者使用其他无监督学习技术来执行异常检测，或者简单的可视化和聚类。你知道吗