Блог

У меня есть набор данных из 25000 цветных изображений 100 * 100 (* 3), и я пытаюсь построить простую нейронную сеть с одним сверточным слоем. Это изображения клеток, которые заражены малярией или нет, поэтому мой результат равен 2. Но для каждой партии я получаю точность 0%. Мои пакеты имеют размер 1, но я пробовал с другим размером, и я все еще получаю точность 0%.

Мой CNN :

 def simple_nn(X_training, Y_training, X_test, Y_test):
    input = 100*100*3
    h1 = 100
    batch_size = 1
    learning_rate = 0.000001
    dropout = 0.2

    X = tf.placeholder(tf.float32, [batch_size, 100, 100, 3], name="is_train")
    Y_ = tf.placeholder(tf.float32, [None, 2])

    #Layers
    conv1 = tf.layers.conv2d(X, filters=64, kernel_size=4,
                         strides=2, padding='SAME',
                         activation=tf.nn.relu, name="conv1")
    conv1 = tf.layers.batch_normalization(conv1)
    conv1 = tf.layers.max_pooling2d(conv1, 2, 2)

    conv2 = tf.layers.conv2d(conv1, filters=128, kernel_size=3,
                         strides=2, padding='SAME',
                         activation=tf.nn.relu, name="conv2")
    conv2 = tf.layers.dropout(conv2, rate=dropout)

    conv3 = tf.layers.conv2d(conv2, filters=256, kernel_size=3,
                     strides=2, padding='SAME',
                     activation=tf.nn.relu, name="conv3")
    conv3 = tf.layers.dropout(conv3, rate=dropout)

    conv4 = tf.layers.conv2d(conv3, filters=64, kernel_size=3,
                     strides=2, padding='SAME',
                     activation=tf.nn.relu, name="conv4")
    conv4 = tf.layers.max_pooling2d(conv4, 2, 2)

    conv5 = tf.layers.conv2d(conv4, filters=32, kernel_size=3,
                         strides=2, padding='SAME',
                         activation=tf.nn.relu, name="conv5")
    Y = tf.reshape(conv5, [batch_size,-1])
    logits = tf.layers.dense(Y, units=2, activation=tf.nn.relu)

    # loss function
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=Y_, logits=logits)
    loss = tf.reduce_mean(tf.cast(cross_entropy, tf.float32))

    # % of correct answers found in batch
    is_correct = tf.equal(tf.argmax(Y,1), tf.argmax(Y_,1))
    accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))


    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
    train_step = optimizer.minimize(cross_entropy)

    init = tf.global_variables_initializer()

    sess = tf.Session()
    sess.run(init)

    for i in range(math.floor(len(X_training)/batch_size)):
        st = batch_size * i
        end = st   batch_size

        if end >= math.floor(len(X_training)) - batch_size:
            break
        batch_X, batch_Y = X_training[st:end], Y_training[st:end]
        train_data={X: batch_X, Y_: batch_Y}

        sess.run(train_step, feed_dict=train_data)

        #Get the accuracy and loss
        a, l = sess.run([accuracy, cross_entropy], feed_dict=train_data)
        print("acc : " str(a) " , loss : " str(l))
  

Мой вывод :

 acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.69436306]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931662]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6925567]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.69259375]
acc : 0.0 , loss : [0.6912933]
acc : 0.0 , loss : [0.6957785]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6990725]
acc : 0.0 , loss : [0.69037354]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6991633]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.6931472]
acc : 0.0 , loss : [0.700589]
acc : 0.0 , loss : [0.6931472]
  

Я получал 65% (имеется в виду acc=0.65 ) с простым не сверточным слоем, но с тех пор, как я переключился на conv, acc=0.0 . Сначала я понял, что по какой-то причине точность была возвращена в моей переменной loss при использовании сверточных слоев, но сейчас я так не думаю, что-то не так в моей функции потерь, я думаю.
И даже если я уменьшу свою модель до одного уровня, произойдет то же самое, а моя loss все еще существует 0.69 .

Вы должны минимизировать уменьшенный вектор. Измените эту строку

train_step = optimizer.minimize(cross_entropy)

к этому:

train_step = optimizer.minimize(loss)

Кроме того, вы не включаете logits layer в вычисление точности. Сделайте это:

 is_correct = tf.equal(tf.argmax(logits,1), tf.argmax(Y_,1))
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
  

Кроме того, вы применяете две активации к logits слою. Сначала у вас есть tf.nn.relu , а затем вы используете softmax (с tf.nn.softmax_cross_entropy_with_logits_v2() ). Не уверен, что вы делаете это намеренно.