Résultats sparse_softmax_cross_entropy_with_logits est pire que softmax_cross_entropy_with_logits

Question

je mets en œuvre problème de classification d'image classique avec tensorflow, j'ai 9 classes, d'abord j'utilise softmax_cross_entropy_with_logits comme classificateur et le réseau ferroviaire, après quelques étapes qu'il donne à environ la précision des trains de 99%,

Ensuite tester le même problème avec sparse_softmax_cross_entropy_with_logits cette fois il ne converge pas du tout, (précision du train est d'environ 0,10 et 0,20)

Seulement pour vos informations, pour softmax_cross_entropy_with_logits, j'utilise [batch_size, num_classes] avec DTYPE float32 pour les étiquettes, et pour sparse_softmax_cross_entropy_with_logits j'utilise [batch_size] avec dtype int32 fo r étiquettes.

Est-ce que quelqu'un a une idée?

Mise à jour:

this is code: 

def costFun(self): 
    self.y_ = tf.reshape(self.y_, [-1]) 
    return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(self.score_, self.y_)) 

def updateFun(self): 
    return tf.train.AdamOptimizer(learning_rate = self.lr_).minimize(self.cost_) 

def perfFun(self): 
    correct_pred = tf.equal(tf.argmax(self.score_,1), tf.argmax(y,1)) 
    return(tf.reduce_mean(tf.cast(correct_pred, tf.float32))) 

def __init__(self,x,y,lr,lyr1FilterNo,lyr2FilterNo,lyr3FilterNo,fcHidLyrSize,inLyrSize,outLyrSize, keepProb): 

    self.x_   = x 
    self.y_   = y 
    self.lr_   = lr 
    self.inLyrSize  = inLyrSize 
    self.outLyrSize_ = outLyrSize 
    self.lyr1FilterNo_ = lyr1FilterNo 
    self.lyr2FilterNo_ = lyr2FilterNo 
    self.lyr3FilterNo_ = lyr3FilterNo 
    self.fcHidLyrSize_ = fcHidLyrSize 
    self.keepProb_  = keepProb 

    [self.params_w_, self.params_b_] = ConvNet.paramsFun(self) 
    self.score_, self.PackShow_  = ConvNet.scoreFun (self) 
    self.cost_      = ConvNet.costFun (self) 
    self.update_      = ConvNet.updateFun(self) 
    self.perf_      = ConvNet.perfFun (self) 

principale:

lyr1FilterNo = 32 
lyr2FilterNo = 64 
lyr3FilterNo = 128 

fcHidLyrSize = 1024 
inLyrSize = 32 * 32 

outLyrSize = 9 
lr   = 0.001 
batch_size = 300 

dropout  = 0.5 
x   = tf.placeholder(tf.float32, [None, inLyrSize ]) 
y   = tf.placeholder(tf.int32, None   ) 

ConvNet_class = ConvNet(x,y,lr,lyr1FilterNo,lyr2FilterNo,lyr3FilterNo,fcHidLyrSize,inLyrSize,outLyrSize, keepProb) 
initVar = tf.global_variables_initializer() 


with tf.Session() as sess: 
    sess.run(initVar) 

    for step in range(10000): 

     trData_i = np.reshape(trData_i , (-1, 32 * 32)) 
     trLabel_i = np.reshape(trLabel_i, (-1, 1  )) 

     update_i, PackShow, wLyr1_i, wLyr2_i, wLyr3_i = sess.run([ConvNet_class.update_, ConvNet_class.PackShow_, 
          ConvNet_class.params_w_['wLyr1'], ConvNet_class.params_w_['wLyr2'], ConvNet_class.params_w_['wLyr3']], 
          feed_dict = { x:trData_i, y:trLabel_i, keepProb:dropout}) 

Answer 1

J'ai trouvé le problème, grâce à @mrry des commentaires utiles, en fait je me trompe sur le calcul de la précision, en fait, « sparse_softmax "et" softmax "a la même perte (ou coût) pour les logits d'entrée,

pour la précision de calcul, je change

correct_pred = tf.equal(tf.argmax(self.score_,1), tf.argmax(y,1))

à

correct_pred = tf.equal(tf.argmax(self.score_,1), y))

puisque dans "sparse_softmax" les étiquettes de vérité au sol ne sont pas au format d'un chaud vecteur, mais réel int32 ou numéros int64.