2017-10-13 5 views
7

En tant qu'expérience, je construis un modèle keras pour approcher le déterminant d'une matrice. Cependant, quand je cours, la perte diminue à chaque époque et la perte de validation augmente! Par exemple:Comment approcher le déterminant avec keras

8s - loss: 7573.9168 - val_loss: 21831.5428 
Epoch 21/50 
8s - loss: 7345.0197 - val_loss: 23594.8540 
Epoch 22/50 
13s - loss: 7087.7454 - val_loss: 24718.3967 
Epoch 23/50 
7s - loss: 6851.8714 - val_loss: 25624.8609 
Epoch 24/50 
6s - loss: 6637.8168 - val_loss: 26616.7835 
Epoch 25/50 
7s - loss: 6446.8898 - val_loss: 28856.9654 
Epoch 26/50 
7s - loss: 6255.7414 - val_loss: 30122.7924 
Epoch 27/50 
7s - loss: 6054.5280 - val_loss: 32458.5306 
Epoch 28/50 

Voici le code complet:

import numpy as np 
import sys 
from scipy.stats import pearsonr 
from scipy.linalg import det 
from sklearn.model_selection import train_test_split 
from tqdm import tqdm 
from sklearn.preprocessing import StandardScaler 
from sklearn.pipeline import Pipeline 
import math 
import tensorflow as tf 
from keras.models import Sequential 
from keras.layers import Dense 
from keras.wrappers.scikit_learn import KerasRegressor 
from keras import backend as K 

def baseline_model(): 
# create model 
     model = Sequential() 
     model.add(Dense(200, input_dim=n**2, kernel_initializer='normal', activation='relu')) 
     model.add(Dense(1, input_dim=n**2)) 
     #  model.add(Dense(1, kernel_initializer='normal')) 
     # Compile model 
     model.compile(loss='mean_squared_error', optimizer='adam') 
     return model 


n = 15 

print("Making the input data using seed 7", file=sys.stderr) 
np.random.seed(7) 
U = np.random.choice([0, 1], size=(n**2,n)) 
#U is a random orthogonal matrix 
X =[] 
Y =[] 
# print(U) 
for i in tqdm(range(100000)): 
     I = np.random.choice(n**2, size = n) 
     # Pick out the random rows and sort the rows of the matrix lexicographically. 
     A = U[I][np.lexsort(np.rot90(U[I]))] 
     X.append(A.ravel()) 
     Y.append(det(A)) 

X = np.array(X) 
Y = np.array(Y) 

print("Data created") 

estimators = [] 
estimators.append(('standardize', StandardScaler())) 
estimators.append(('mlp', KerasRegressor(build_fn=baseline_model, epochs=50, batch_size=32, verbose=2))) 
pipeline = Pipeline(estimators) 
X_train, X_test, y_train, y_test = train_test_split(X, Y, 
                train_size=0.75, test_size=0.25) 
pipeline.fit(X_train, y_train, mlp__validation_split=0.3) 

Comment puis-je arrêter overfitting si mal?


Update 1

J'ai essayé d'ajouter plus de couches et la régularisation L_2. Cependant, il fait peu ou pas de différence.

def baseline_model(): 
# create model 
     model = Sequential() 
     model.add(Dense(n**2, input_dim=n**2, kernel_initializer='glorot_normal', activation='relu')) 
     model.add(Dense(int((n**2)/2.0), kernel_initializer='glorot_normal', activation='relu', kernel_regularizer=regularizers.l2(0.01))) 
     model.add(Dense(int((n**2)/2.0), kernel_initializer='glorot_normal', activation='relu', kernel_regularizer=regularizers.l2(0.01))) 
     model.add(Dense(int((n**2)/2.0), kernel_initializer='glorot_normal', activation='relu', kernel_regularizer=regularizers.l2(0.01))) 
     model.add(Dense(1, kernel_initializer='glorot_normal')) 
     # Compile model 
     model.compile(loss='mean_squared_error', optimizer='adam') 
     return model 

I a augmenté le nombre d'époques à 100 et il termine avec:

19s - loss: 788.9504 - val_loss: 18423.2807 
Epoch 97/100 
24s - loss: 760.2046 - val_loss: 18305.9273 
Epoch 98/100 
20s - loss: 806.0941 - val_loss: 18174.8706 
Epoch 99/100 
24s - loss: 780.0487 - val_loss: 18356.7482 
Epoch 100/100 
27s - loss: 749.2595 - val_loss: 18331.5859 

Est-il possible de rapprocher le déterminant d'une matrice en utilisant keras?

+0

Ce n'est pas surapprentissage, votre modèle ne correspond pas aux données. Le modèle est juste trop simple. –

+0

@MatiasValdenegro La raison pour laquelle je l'ai appelée overfitting est que la perte continue à descendre vers 0 et que validation_loss continue de continuer. Augmenter le nombre de nœuds dans la couche cachée n'aide pas du tout. Que feriez-vous ensuite? – eleanora

+0

Augmentez le nombre de couches masquées. Initialisez les calques cachés en utilisant 'glorot'. Utilisez «dropout» ou «l2 regularizer» – Nain

Répondre

3

J'ai testé votre code et obtenu le même résultat. Mais passons à la compréhension de base du déterminant de la matrice (DET). DET se compose de n! produits, donc vous ne pouvez pas vraiment l'approximer avec n * n poids dans quelques couches de réseau neuronal. Cela nécessite un nombre de poids qui ne serait pas à l'échelle de n = 15, puisque 15! est 1307674368000 termes pour la multiplication dans le DET.

+0

Ce n'est pas clair pour moi. Le DET peut être calculé en n^3 bien sûr (pas n!). En outre, si vous exécutez le modèle keras pour des centaines d'époques, la perte sur l'ensemble d'entraînement descend à près de 0. – eleanora

+0

En fait, c'est une formule bien définie qui prend seulement +1 et -1 comme poids, mais implique beaucoup des multiplications des entrées. Pas sûr que ce soit un bon cas pour essayer des réseaux neuronaux simples. –

+0

@eleanora vous confondez le nombre de termes avec la complexité de calcul. – denfromufa