Multilabel de la Classification de textes à l'aide de TensorFlow

Les données de texte est organisé comme vecteur avec 20 000 éléments, comme [2, 1, 0, 0, 5, ...., 0].
i-ème élément indique la fréquence de la i-ème mot dans un texte.

La vérité du terrain les données de l'étiquette est également représenté comme un vecteur de 4 000 éléments, comme [0, 0, 1, 0, 1, ...., 0].
i-ème élément indique si la i-ème de l'étiquette est un positif de l'étiquette de texte.
Le nombre d'étiquettes pour un texte qui diffère selon les textes.

J'ai un code pour un seul texte de l'étiquette de classement.

Comment puis-je modifier le code suivant pour multilabel de la classification de textes?

Surtout, je voudrais savoir points suivants.

  • Comment faire pour calculer la précision à l'aide de TensorFlow.
  • Comment définir un seuil au-delà duquel les juges que l'étiquette soit positif ou négatif. Par exemple, si la sortie est [0.80, 0.43, 0.21, 0.01, 0.32] et la vérité du terrain est [1, 1, 0, 0, 1], les étiquettes avec des scores de plus de 0.25 devrait être jugé comme positif.

Merci. 

import tensorflow as tf
# hidden Layer
class HiddenLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_h = tf.Variable(tf.random_normal([n_in, n_out],mean = 0.0,stddev = 0.05))
b_h = tf.Variable(tf.zeros([n_out]))
self.w = w_h
self.b = b_h
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
self.output = tf.nn.relu(linarg)
return self.output
# output Layer
class OutputLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_o = tf.Variable(tf.random_normal([n_in, n_out], mean = 0.0, stddev = 0.05))
b_o = tf.Variable(tf.zeros([n_out]))
self.w = w_o
self.b = b_o
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
self.output = tf.nn.relu(linarg)
return self.output
# model
def model():
h_layer = HiddenLayer(input = x, n_in = 20000, n_out = 1000)
o_layer = OutputLayer(input = h_layer.output(), n_in = 1000, n_out = 4000)
# loss function
out = o_layer.output()
cross_entropy = -tf.reduce_sum(y_*tf.log(out + 1e-9), name='xentropy')    
# regularization
l2 = (tf.nn.l2_loss(h_layer.w) + tf.nn.l2_loss(o_layer.w))
lambda_2 = 0.01
# compute loss
loss = cross_entropy + lambda_2 * l2
# compute accuracy for single label classification task
correct_pred = tf.equal(tf.argmax(out, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, "float"))
return loss, accuracy
  • Je pense qu'il y a peut-être une meilleure perte de fonction à utiliser en plus d'entropie croisée.
  • Il ya beaucoup de différentes mesures de précision pour un multilabel classification problème: une erreur de précision, grade, la perte, la moyenne de la précision, etc. Je suis encore à apprendre TensorFlow moi-même et je n'ai pas réussi à mettre correctement en œuvre l'un d'eux encore. Mais peut-être que ce livre vous aidera à: arxiv.org/pdf/1312.5419v3.pdf Laissez-moi savoir si vous faites des progrès!
  • Pour avoir une meilleure idée de la précision envisager de calculer la précision et le rappel.
  • qu'est-ce que y_ je ne vois pas défini
InformationsquelleAutor Benben | 2016-02-15
  1. 12

    Changement relu à sigmoïde de la couche de sortie.
    Modifier la croix entropie explicite à la formule mathématique de la croix entropie (explicite, la perte a été de travailler dans mon cas, la version de tensorflow )

    import tensorflow as tf
# hidden Layer
class HiddenLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_h = tf.Variable(tf.random_normal([n_in, n_out],mean = 0.0,stddev = 0.05))
b_h = tf.Variable(tf.zeros([n_out]))
self.w = w_h
self.b = b_h
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
self.output = tf.nn.relu(linarg)
return self.output
# output Layer
class OutputLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_o = tf.Variable(tf.random_normal([n_in, n_out], mean = 0.0, stddev = 0.05))
b_o = tf.Variable(tf.zeros([n_out]))
self.w = w_o
self.b = b_o
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
#changed relu to sigmoid
self.output = tf.nn.sigmoid(linarg)
return self.output
# model
def model():
h_layer = HiddenLayer(input = x, n_in = 20000, n_out = 1000)
o_layer = OutputLayer(input = h_layer.output(), n_in = 1000, n_out = 4000)
# loss function
out = o_layer.output()
# modified cross entropy to explicit mathematical formula of sigmoid cross entropy loss
cross_entropy = -tf.reduce_sum( (  (y_*tf.log(out + 1e-9)) + ((1-y_) * tf.log(1 - out + 1e-9)) )  , name='xentropy' )    
# regularization
l2 = (tf.nn.l2_loss(h_layer.w) + tf.nn.l2_loss(o_layer.w))
lambda_2 = 0.01
# compute loss
loss = cross_entropy + lambda_2 * l2
# compute accuracy for single label classification task
correct_pred = tf.equal(tf.argmax(out, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, "float"))
return loss, accuracy
    InformationsquelleAutor Alok Nayak
  2. 14

    Vous devez utiliser les variations de la croix de l'entropie de la fonction dans d'autres à l'appui de multilabel de classification. Dans le cas où vous avez moins d'un millier de ouputs vous devez utiliser sigmoid_cross_entropy_with_logits, dans votre cas, vous avez 4000 sorties, vous pouvez envisager de candidat échantillonnage car il est plus rapide que la précédente.

    Comment faire pour calculer la précision à l'aide de TensorFlow.

    Cela dépend de votre problème et ce que vous voulez atteindre. Si vous ne voulez pas manquer n'importe quel objet dans une image puis si le classificateur obtenir tout droit, mais un seul, alors vous devriez considérer l'ensemble de l'image une erreur. Vous pouvez également envisager qu'un objet oublié ou missclassiffied est une erreur. La dernière, je pense que c'pris en charge par sigmoid_cross_entropy_with_logits.

    Comment définir un seuil au-delà duquel les juges que l'étiquette soit positif ou
    négatif. Par exemple, si la sortie est [0.80, 0.43, 0.21, 0.01,
    0.32] et la vérité du terrain est [1, 1, 0, 0, 1], les étiquettes avec des scores de plus de 0.25 devrait être jugé comme positif.

    Seuil est une façon d'aller, vous avez à décider lequel. Mais c'est une sorte de hack, pas de réel multilable de classification. Pour cela vous devez les fonctions précédentes je l'ai dit avant.

    • Je ne sais pas pourquoi les gens suggèrent 'sigmoid_cross_entropy_with_logits'. Si c'est ce que son nom l'indique je.e -Y*ln(sigmoïde(logits)) . Ensuite, il permettra de minimiser la perte en accordant une haute probabilité de chaque classe, et en fait il était en train de donner que dans mon cas.
    • cette fonction ne retourne pas une probabilité. Et je ne vois pas comment il va minimiser la perte en donnant une valeur élevée. Si vous le réglez sur 1 pour vos classes et 0 quand la classe n'est pas présent, alors le réseau donne des valeurs proches de 0 lorsque l'objet n'est pas dans l'image et les valeurs proches de 1 ou plus grand (même 2 o 3) si l'objet est dans l'image. Je l'utilise et fonctionne plutôt bien.
    • Il permettra de minimiser la perte en donnant une valeur élevée pour chaque classe, car il n'y a pas de pénalité(ou 0 perte) de donner une grande valeur aux classes qui sont étiquetés 0. Donc, on a besoin de modifier la croix entropie binaire de la croix de l'entropie (y * ln(sigmoïde(logits)) + 1-y * ln(sigmoïde(1-logits))) . sigmoid_cross_entropy_with_logits ne pas mettre en œuvre binaire de la croix de l'entropie à l'interne. Je suis surpris pourquoi est-il de travail dans votre cas, êtes-vous à l'aide de théano, etc
    • Je pense que vous êtes mal avec les maths. Il est: y * ln(sigmoïde(logits)) + (1-y) * ln(1-sigmoïde(logits)) Donc: logits=0, y=0 => 0 ; logits=1, y=1 => 0 ; logits=1, y=0 => 1.3 ; logits=0, y=1 => 1.3 ; Vous pouvez tracer la fonction dans google un jouer avec les nombres. Il suffit de chercher pour y*-ln (1 / ( 1 + e^-x)) +(1-y)*-ln (1-1 / ( 1 + e^-x))
    • Mon mauvais, Ignorer ma au-dessus de mathématiques. Voici ce que j'ai été en utilisant, ce qui a fonctionné pour moi, -tf.reduce_mean(tf.mul(y,tf.log(tf.nn.sigmoïde(logits) + 1e-9)) + tf.mul(1-y,tf.log(1 - tf.nn.sigmoïde(logits) + 1e-9))) . Ce qui a fonctionné et ce que vous vous proposez ne fonctionne pas, laissez-moi savoir si je me trompe avec mon argument
    • Il pourrait être la version de tensorflow que vous utilisez. Les équations sont presque les mêmes (vous avez ajouté un petit nombre pour éviter les 0s et dans tensorflow ils utilisent une fonction max). Vous argument est faux, si vous remplacez les valeurs dans l'équation que vous obtenez des erreurs lors de logits et y ne correspond pas et 0 lorsqu'ils sont les mêmes. Donc je ne sais pas pourquoi il ne fonctionne pas pour vous, mais les équations sont ok.
    • Pas de doute, si je remplace les valeurs dans mon équation, j'obtiens une erreur lors de logits et y ne correspond pas et 0 lorsqu'ils sont les mêmes.Pas de doute au sujet de ma perte defination. Mais dans tensorflow s 'sigmoid_cross_entropy_with_logits'. perte = -Y*ln(sigmoïde(logits)) . Veuillez justifier cette perte n'est pas la perte que j'ai utilisé
    • Je parlais de TF, j'ai écrit l'équation et de le tester. Le faire vous-même, il fonctionne. Je n'ai pas de vérifier vos équations. Dis-moi avec qui les valeurs de la equatiosn de TF ne fonctionne pas
    • Ce que vous voulez dire, c'est qu'il ne fonctionne pas pour vous. Il travaille pour moi très bien depuis quelques mois. sigmoid_cross_entropy_with_logits ne pas utiliser l'équation que vous avez dit, il utilise celui que j'ai écrit avant (c'est dans les docts de tensorflow): y * ln(sigmoïde(logits)) + (1-y) * ln(1-sigmoïde(logits))

    InformationsquelleAutor jorgemf