2017-09-29 4 views
0

J'apprends actuellement le tensorflow. J'ai essayé de faire un modèle de classification en utilisant le modèle softmax. Dans le programme, j'ai placé l'ensemble de données d'entraînement sur le côté gauche de deux colonnes et deux étiquettes sur le côté droit de deux colonnes dans un fichier CSV. Tels que:tensorflow sur les classifications

Data1, Data2, label1, label2
234, 23, 1, 0 # 234 est plus grand que 23, donc label1 est étiqueté comme 1 et label2 étiqueté comme 0
156, 113, 1, 0
1, 4, 0, 1

Il fonctionne pour classer les données de test avec la plus grande base de nombre sur l'ensemble de données d'entraînement comme ci-dessus, et la valeur de coût est convertie à près de zéro.

Cependant, je change l'ensemble de données pour étiqueter le nombre pair qui vise à classer les données de test en nombre pair, le modèle échoue, tandis que le coût est fluctuant. L'ensemble de données est la suivante:

Data1, Data2, label1, label2
24, 35, 1, 0 # 24 est un nombre pair, donc label1 est étiqueté comme 1 et label2 étiqueté comme 0
156, 553, 1, 0
1, 4, 0, 1

Est-ce que je me trompe avec le programme? Pourquoi cela fonctionne-t-il en distinguant le plus grand nombre de données, tout en échouant en nombre pair? Merci a tous! Voici mon code:

import tensorflow as tf 
import os 
import numpy as np 


def next_batch(num, data, labels): 
    idx = np.arange(0 , len(data)) 
    np.random.shuffle(idx) 
    idx = idx[:num] 
    data_shuffle = [data[ i] for i in idx] 

    labels_shuffle = [labels[ i] for i in idx] 
    return np.asarray(data_shuffle), np.asarray(labels_shuffle) 

dir_path = os.path.dirname(os.path.realpath(__file__)) 

filename = dir_path + "/classification.csv" 

x = tf.placeholder(tf.float32, [None, 2]) 
y = tf.placeholder(tf.float32, [None, 2]) 
W = tf.Variable(tf.zeros([2, 2])) 
b = tf.Variable(tf.zeros([2])) 

pred =tf.add(tf.matmul(x, W),b) 

cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y)) 
optimizer = tf.train.GradientDescentOptimizer(0.1).minimize(cost) 

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

    with open(filename) as inf: 
     # Skip header 
     next(inf) 
     result_array = np.shape(4) 
     for line in inf: 

      data1, data2,label1,label2= line.strip().split(",") 

      data1 = float(data1) 
      data2 = float(data2) 
      label1 = int(label1) 
      label2 = int(label2) 
      result_array = np.append(result_array, (data1,data2,label1,label2)) 

    result_array=result_array.reshape(1000,4) 
    k=result_array[:,2:4] 
    gg=result_array[:,0:2] 
    for i in range(0,3000): 
     batch_xs, batch_ys = next_batch(200,gg,k) 

     h,cos=sess.run([optimizer, cost], feed_dict={x: batch_xs,y:batch_ys}) 
     print(cos) 

    print(sess.run(pred,feed_dict={x:[[5,2],[4,9],[4,3],[5,2],[3,6],[30,21],[32,20],[3,4]]})) #testing data 

Répondre

0

Vous avez une seule couche de neurones, ce qui signifie que votre réseau ne peut résoudre les problèmes de façon linéaire séparables. Déterminer si un nombre entier est pair ou impair n'est pas linéairement séparable (vous ne pouvez pas tracer tous les entiers et tracer une seule ligne entre les nombres pairs et les nombres impairs). Essayez d'ajouter un autre calque qui prend la sortie de la première couche en entrée et entraîne ce réseau à la place. Cependant, vous aurez besoin de plus d'une sortie de la première couche. Deux ou trois pourraient suffire. C'est assez pour XOR, mais je n'ai pas essayé ce problème particulier.