python - sentimientos - Clasificación de texto Multilabel con TensorFlow

procesar texto python

Question

Los datos de texto se organizan como vector con 20,000 elementos, como [2, 1, 0, 0, 5, ...., 0]. El elemento i-ésimo indica la frecuencia de la i-ésima palabra en un texto.

Los datos de la etiqueta de verdad del suelo también se representan como vector con 4,000 elementos, como [0, 0, 1, 0, 1, ...., 0]. El elemento i-ésimo indica si la etiqueta i-ésima es una etiqueta positiva para un texto. La cantidad de etiquetas para un texto varía según los textos.

Tengo un código para la clasificación de texto de etiqueta única.

¿Cómo puedo editar el siguiente código para la clasificación de texto multilabel?

Especialmente, me gustaría saber los siguientes puntos.

• Cómo calcular la precisión con TensorFlow.
• Cómo establecer un umbral que juzga si una etiqueta es positiva o negativa. Por ejemplo, si el resultado es [0.80, 0.43, 0.21, 0.01, 0.32] y la verdad del terreno es [1, 1, 0, 0, 1], las etiquetas con puntajes superiores a 0.25 se deben considerar positivas.

Gracias.

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

Answer 1

Cambiar relu a sigmoid de la capa de salida. Modificar la pérdida de entropía cruzada a la fórmula matemática explícita de la pérdida de entropía cruzada sigmoidea (la pérdida explícita estaba funcionando en mi caso / versión 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

Answer 2

Tienes que usar variaciones de la función de entropía cruzada en otra para admitir la clasificación multilable. En caso de que tenga menos de mil salidas, debe usar sigmoid_cross_entropy_with_logits , en su caso que tiene 4000 salidas, puede considerar el muestreo de candidatos ya que es más rápido que el anterior.

Cómo calcular la precisión con TensorFlow.

Esto depende de tu problema y de lo que quieras lograr. Si no quieres perderte ningún objeto en una imagen, entonces si el clasificador está bien, solo uno, entonces debes considerar la imagen completa como un error. También puede considerar que un objeto perdido o falta de clasificación es un error. Este último creo que es compatible con sigmoid_cross_entropy_with_logits.

Cómo establecer un umbral que juzga si una etiqueta es positiva o negativa. Por ejemplo, si el resultado es [0.80, 0.43, 0.21, 0.01, 0.32] y la verdad del terreno es [1, 1, 0, 0, 1], las etiquetas con puntajes superiores a 0.25 se deben considerar positivas.

El umbral es un camino por recorrer, tienes que decidir cuál. Pero eso es algún tipo de hackeo, no una clasificación real multilable. Para eso necesitas las funciones previas que dije antes.