Réseau de neurones toujours prédit la même classe

Je suis en train de mettre en œuvre un réseau de neurones qui classe les images dans l'une des deux catégories distinctes. Le problème est, cependant, qu'il a toujours prédit 0 pour toute entrée et je ne suis pas vraiment sûr de savoir pourquoi.

Voici ma fonction de la méthode d'extraction:

def extract(file):
    # Resize and subtract mean pixel
    img = cv2.resize(cv2.imread(file), (224, 224)).astype(np.float32)
    img[:, :, 0] -= 103.939
    img[:, :, 1] -= 116.779
    img[:, :, 2] -= 123.68
    # Normalize features
    img = (img.flatten() - np.mean(img)) / np.std(img)

    return np.array([img])

Voici ma descente de gradient de routine:

def fit(x, y, t1, t2):
    """Training routine"""
    ils = x.shape[1] if len(x.shape) > 1 else 1
    labels = len(set(y))

    if t1 is None or t2 is None:
        t1 = randweights(ils, 10)
        t2 = randweights(10, labels)

    params = np.concatenate([t1.reshape(-1), t2.reshape(-1)])
    res = grad(params, ils, 10, labels, x, y)
    params -= 0.1 * res

    return unpack(params, ils, 10, labels)

Voici mon avant et à l'arrière(gradient) propagations:

def forward(x, theta1, theta2):
"""Forward propagation"""
m = x.shape[0]
# Forward prop
a1 = np.vstack((np.ones([1, m]), x.T))
z2 = np.dot(theta1, a1)
a2 = np.vstack((np.ones([1, m]), sigmoid(z2)))
a3 = sigmoid(np.dot(theta2, a2))
return (a1, a2, a3, z2, m)
def grad(params, ils, hls, labels, x, Y, lmbda=0.01):
"""Compute gradient for hypothesis Theta"""
theta1, theta2 = unpack(params, ils, hls, labels)
a1, a2, a3, z2, m = forward(x, theta1, theta2)
d3 = a3 - Y.T
print('Current error: {}'.format(np.mean(np.abs(d3))))
d2 = np.dot(theta2.T, d3) * (np.vstack([np.ones([1, m]), sigmoid_prime(z2)]))
d3 = d3.T
d2 = d2[1:, :].T
t1_grad = np.dot(d2.T, a1.T)
t2_grad = np.dot(d3.T, a2.T)
theta1[0] = np.zeros([1, theta1.shape[1]])
theta2[0] = np.zeros([1, theta2.shape[1]])
t1_grad = t1_grad + (lmbda / m) * theta1
t2_grad = t2_grad + (lmbda / m) * theta2
return np.concatenate([t1_grad.reshape(-1), t2_grad.reshape(-1)])

Et voici ma fonction de prédiction:

def predict(theta1, theta2, x):
"""Predict output using learned weights"""
m = x.shape[0]
h1 = sigmoid(np.hstack((np.ones([m, 1]), x)).dot(theta1.T))
h2 = sigmoid(np.hstack((np.ones([m, 1]), h1)).dot(theta2.T))
return h2.argmax(axis=1)

Je peux voir que le taux d'erreur diminue progressivement à chaque itération, généralement convergent, quelque part autour de 1.26 e-05.

Ce que j'ai essayé jusqu'à présent:

  1. PCA
  2. Différents ensembles de données (Iris à partir de sklearn manuscrits et des numéros de Coursera ML sûr, la réalisation de près de 95% de précision sur les deux). Toutefois, ces deux ont été traitées dans un lot, donc je peux supposer que mon général, la mise en œuvre est correcte, mais il ya quelque chose de mal avec soit la façon dont j'ai extrait de fonctionnalités, ou comment j'ai former le classificateur.
  3. Essayé sklearn de SGDClassifier et elle n'a pas joué beaucoup mieux, me donner un ~50% de précision. Donc quelque chose de mal avec les fonctions, alors?

Modifier:
Un moyen de sortie de h2 se présente comme suit:

[0.5004899   0.45264441]
[0.50048522  0.47439413]
[0.50049019  0.46557124]
[0.50049261  0.45297816]

Donc, très semblable sigmoïde sorties pour tous les exemples de validation.

  • Une seule pensée, êtes-vous randomisation votre formation? Si il y a un tas de 0 classe dans la première lots, il est possible qu'il devient concentré sur eux, très tôt.
  • Les données sont commandés, c'est à dire: 10000 de 0s, puis 10000 de 1s.
  • Viens de réaliser que vous avez dit "batch". Je pense que j'étais prête à confusion avec le "mini-batch" lorsque cela est un problème commun. Il faudra que je pense à propos de ce peu plus.
  • Juste pour info: j'ai essayé de randomisation des données d'entrée et le résultat est toujours le même.
  • Essayer de retourner les premières h2 valeurs de votre finale predict appel. Sont-elles toutes les mêmes?
  • Oui, à environ 0.4/0.6.
  • Voir aussi: Pourquoi mon ICRA 100 CNN modèle, principalement prévoir deux classes?

InformationsquelleAutor Yurii Dolhikh | 2017-01-05
  1. 58

    Mon réseau n'est toujours prédire la même classe. Quel est le problème?

    J'ai eu ce une couple de fois. Bien qu'actuellement, je suis trop paresseux pour aller à travers votre code, je pense que je peux donner quelques conseils généraux qui pourraient aussi aider les autres qui ont le même symptôme, mais probablement différents problèmes sous-jacents.

    Le Débogage Des Réseaux De Neurones

    Côté d'un élément ensembles de données

    Pour chaque classe i le réseau doit être en mesure de prédire, essayez les solutions suivantes:

    1. Créer un jeu de données d'un seul point de données de la classe i.
    2. Adapter le réseau pour cet ensemble de données.
    3. Le réseau apprendre à prédire "classe i"?

    Si cela ne fonctionne pas, il existe quatre sources d'erreur:

    1. Buggy algorithme de formation: Essayez un modèle de taille plus petite, de l'impression d'un lot de valeurs, qui sont calculés entre et de voir si ceux qui correspondent à votre attente.
      1. Division par 0: Ajouter un petit nombre de dénominateur
      2. Logarithme de 0 /nombre négatif: Comme la division par 0
    2. Données: Il est possible que vos données ont pas le bon type. Par exemple, il peut être nécessaire que vos données est de type float32 mais en fait est un entier.
    3. Modèle: Il est également possible que vous venez de créer un modèle qui ne peut pas prédire ce que vous voulez. Cela devrait être révélé lorsque vous essayez des modèles plus simples.
    4. Initialisation /Optimisation: Selon le modèle, votre initialisation et de votre algorithme d'optimisation pourrait jouer un rôle crucial. Pour les débutants qui utilisent la norme de la descente de gradient stochastique, je dirais que c'est surtout important pour initialiser les poids de façon aléatoire (chaque poids une valeur différente). - voir aussi: cette question /réponse

    Courbe D'Apprentissage

    Voir sklearn pour plus de détails.

    Réseau de neurones toujours prédit la même classe

    L'idée est de commencer avec un petit ensemble de données d'apprentissage (probablement un seul élément). Ensuite, le modèle devrait être en mesure d'adapter les données à la perfection. Si cela fonctionne, vous faire un peu plus grand ensemble de données. Votre formation d'erreur devrait légèrement aller jusqu' à un certain point. Cela révèle la capacité des modèles pour modéliser les données.

    L'analyse des données

    Vérifier comment souvent dans l'autre classe(s) apparaissent. Si une classe domine les autres (par exemple, une classe est de 99,9% des données), c'est un problème. Recherchez "de détection de valeurs aberrantes" techniques.

    Plus

    • D'apprentissage taux de: Si votre réseau n'est pas d'améliorer et d'obtenir seulement légèrement mieux que le hasard, essayez de réduire le taux d'apprentissage. Pour la vision par ordinateur, l'apprentissage d'un taux de 0.001 est souvent utilisé de travail. C'est également utile si vous utilisez Adam comme un optimiseur.
    • Prétraitement: assurez-vous d'utiliser le même prétraitement pour la formation et les tests. Vous pouvez voir des différences dans la matrice de confusion (voir cette question)

    Erreurs Les Plus Courantes

    Cela est inspiré par reddit:

    • Vous avez oublié d'appliquer un prétraitement des
    • Mourir ReLU
    • Trop petit /trop grand au taux d'apprentissage
    • Mal de fonction d'activation de couche de finition:
      • Vos cibles ne sont pas en somme un? -> Ne pas utiliser de softmax
      • Des éléments uniques de vos cibles sont négatifs -> Ne pas utiliser de Softmax, ReLU, Sigmoïde. tanh peut-être une option
    • Trop profonde réseau: Vous ne parviennent pas à former. Essayez un simple réseau de neurones en premier.
    • Très déséquilibrée des données: Vous voudrez peut-être regarder dans déséquilibre de l'apprendre
    • Seul les éléments de vos cibles sont négatifs -> Ne pas utiliser de Softmax, ReLU, Sigmoïde. tanh pourrait être une option. Pouvez-vous s'il vous plaît suggérer puis la bonne fonction d'activation dans ce cas?
    • Avez-vous vu que je suggère tanh? Quoi d'autre avez-vous vous attendre? (Vous pouvez toujours concevoir votre propre; parfois linéaire est également une bonne option)
    • j'ai mal lu. Je pensais que tanh est dans la liste des fonctions de ne pas utiliser. Peut-être qu'il devrait être Tanh, comme c'est le premier mot dans la phrase
    InformationsquelleAutor Martin Thoma
  2. 9

    Après une semaine et demi de recherche, je crois que je comprends ce qu'est la question. Il n'y a rien de mal avec le code lui-même. Les deux seuls problèmes qui empêchent ma mise en œuvre de la classification avec succès sont temps consacré à l'apprentissage et du choix de l'apprentissage des taux et des paramètres de régularisation.

    J'ai eu l'apprentissage de routine en cours d'exécution pour certains tomé maintenant, et c'est en poussant à 75% de précision déjà, mais il ya encore beaucoup de place pour l'amélioration.

    InformationsquelleAutor Yurii Dolhikh
  3. 0

    Juste au cas où quelqu'un d'autre rencontre ce problème. Le mien était avec un deeplearning4j Lenet(CNN) architecture, Il continua de donner le résultat final de la dernière formation dossier pour chaque test.
    J'ai été en mesure de le résoudre par increasing my batchsize et shuffling the training data de sorte que chaque lot contenait au moins un échantillon de plus d'un dossier. Ma classe de données avait batchsize de 1 qui était vraiment dangerous.

    Edit: Bien que l'autre chose que j'ai observée récemment est d'avoir des ensembles limités de la formation des échantillons par classe malgré une grande dataset. par exemple la formation d'un neural-network de reconnaître human faces, mais ayant seulement un maximum de dire 2 différents visages pour 1 person dire si l'ensemble des données consiste à dire de 10 000 persons donc un dataset de de 20 000 faces au total. Une meilleure dataset serait 1000 différents faces pour de 10 000 persons
    ainsi, un dataset de de 10 000 000 faces au total. C'est relativement nécessaire si vous voulez éviter surajustement les données d'une classe de sorte que votre network peut facilement généraliser et de produire de meilleurs predictiond.

    InformationsquelleAutor LiNKeR