Como decidir o tamanho de camadas no método Dense Keras'?

votos
4

Abaixo está o exemplo simples de multi-classe tarefa de classificação com dados IRIS.

import seaborn as sns
import numpy as np
from sklearn.cross_validation import train_test_split
from keras.models import Sequential
from keras.layers.core import Dense, Activation, Dropout
from keras.regularizers import l2
from keras.utils import np_utils


#np.random.seed(1335)

# Prepare data
iris = sns.load_dataset(iris)
iris.head()
X = iris.values[:, 0:4]
y = iris.values[:, 4]


# Make test and train set
train_X, test_X, train_y, test_y = train_test_split(X, y, train_size=0.5, random_state=0)


################################
# Evaluate Keras Neural Network
################################


# Make ONE-HOT
def one_hot_encode_object_array(arr):
    '''One hot encode a numpy array of objects (e.g. strings)'''
    uniques, ids = np.unique(arr, return_inverse=True)
    return np_utils.to_categorical(ids, len(uniques))

train_y_ohe = one_hot_encode_object_array(train_y)
test_y_ohe = one_hot_encode_object_array(test_y)


model = Sequential()
model.add(Dense(16, input_shape=(4,),
      activation=tanh,
      W_regularizer=l2(0.001)))
model.add(Dropout(0.5))
model.add(Dense(3, activation='sigmoid'))
model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')


# Actual modelling
# If you increase the epoch the accuracy will increase until it drop at
# certain point. Epoch 50 accuracy 0.99, and after that drop to 0.977, with
# epoch 70 
hist = model.fit(train_X, train_y_ohe, verbose=0,   nb_epoch=100,  batch_size=1)


score, accuracy = model.evaluate(test_X, test_y_ohe, batch_size=16, verbose=0)
print(Test fraction correct (NN-Score) = {:.2f}.format(score))
print(Test fraction correct (NN-Accuracy) = {:.2f}.format(accuracy))

A minha pergunta é como é que as pessoas costumam decidir o tamanho de camadas? Por exemplo baseado no código acima, temos:

model.add(Dense(16, input_shape=(4,),
      activation=tanh,
      W_regularizer=l2(0.001)))
model.add(Dense(3, activation='sigmoid'))

Onde primeiro parâmetro Denseé 16 eo segundo é 3.

  • Por duas camadas utiliza dois valores diferentes para Dense?
  • Como podemos escolher o que é o melhor valor para Dense?
Publicado 30/04/2016 em 02:32
fonte usuário
Em outras línguas...                            


2 respostas

votos
3

Basicamente é apenas tentativa e erro. Esses são chamados de hiperparâmetros e deve ser sintonizado em um conjunto de validação (separação de seus dados originais em trem / validação / teste).

Sintonia significa apenas tentando diferentes combinações de parâmetros e manter a um com o valor da perda menor ou maior precisão sobre o conjunto de validação, dependendo do problema.

Existem dois métodos básicos:

  • Pesquisa Grid: Para cada parâmetro, decidir um intervalo e etapas para que alcance, como 8 a 64 neurônios, em potências de dois (8, 16, 32, 64), e tentar cada combinação de parâmetros. Esta é, obviamente, requer um número exponencial de modelos a serem treinados e testados e leva muito tempo.

  • busca aleatória: Faça o mesmo, mas apenas definir um intervalo para cada parâmetro e tentar um conjunto aleatório de parâmetros, elaborado a partir de uma distribuição uniforme em cada faixa. Você pode tentar como muitos parâmetros define você quer, pois, como quanto tempo você pode. Este é apenas um palpite aleatório informado.

Infelizmente não há nenhuma outra maneira de ajustar esses parâmetros. Sobre camadas com número diferente de neurônios, que poderia vir a partir do processo de ajuste, ou você também pode vê-lo como redução de dimensionalidade, como uma versão compactada da camada anterior.

Respondeu 30/04/2016 em 09:38
fonte usuário

votos
2

Não há nenhuma maneira conhecida para determinar uma boa estrutura de rede avaliando o número de entradas ou saídas. Baseia-se no número de exemplos de treinamento, tamanho do lote, número de épocas, basicamente, em cada parâmetro significativo da rede.

Além disso, um elevado número de unidades pode introduzir problemas como overfitting e explodindo problemas de gradiente. Por outro lado, um menor número de unidades pode causar um modelo de ter valores baixos de precisão elevada e polarização. Mais uma vez, depende do tamanho dos dados utilizados para o treinamento.

Infelizmente ele está tentando alguns valores diferentes que dão os melhores ajustes. Você pode escolher a combinação que lhe dá os menores valores de perda e de perda de validação, bem como a melhor precisão para o seu conjunto de dados, como disse no post anterior.

Você poderia fazer alguma proporção em seu número de valor unidades, algo como:

# Build the model
model = Sequential()
model.add(Dense(num_classes * 8, input_shape=(shape_value,),  activation = 'relu' )) 
model.add(Dropout(0.5))

model.add(Dense(num_classes * 4, activation = 'relu'))
model.add(Dropout(0.2))

model.add(Dense(num_classes * 2, activation = 'relu'))
model.add(Dropout(0.2))

#Output layer
model.add(Dense(num_classes, activation = 'softmax'))

O modelo acima mostra um exemplo de um sistema de inteligência artificial categorização. Os num_classes são o número de categorias diferentes do sistema tem que escolher. Por exemplo, no conjunto de dados da íris de Keras, temos:

  • íri
  • Iris Versicolour
  • Iris Virginica

num_classes = 3

No entanto, isso pode levar a resultados piores do que com outros valores aleatórios. Precisamos ajustar os parâmetros para o conjunto de dados de treinamento, fazendo algumas tentativas diferentes e, em seguida, analisar os resultados buscando a melhor combinação de parâmetros.

Respondeu 02/11/2018 em 12:59
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more