使用CNN对图片进行两类分类，但始终可以将所有内容预测为一类

Question

Introduction

I have a normal CNN network based on tensorflow, and my goal is to train it and then use it to classify the images into 2 classes.

About train dataset

X: Images(healthy, not healthy), 128*128

label: [1, 0] (not healthy) or [0, 1] (healthy)

I use the TFrecords to make the dataset.

About the CNN model

def weight_variable(shape):

    initial = tf.truncated_normal(shape, stddev = 0.1, dtype = tf.float32)
    return tf.Variable(initial)


def bias_variable(shape):

    initial = tf.constant(0.1, shape = shape, dtype = tf.float32)
    return tf.Variable(initial)


def conv2d(x, W):

    #(input, filter, strides, padding)
    #[batch, height, width, in_channels]
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')


def max_pool_2x2(x):

    #(value, ksize, strides, padding)
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

def cnn_model():

    epochs = 1
    batch_size = 200
    learning_rate = 0.001
    hidden = 1024
    cap_c = 498
    cap_h = 478
    num = cap_c + cap_h # the sum number of the training x
    image_size = 128
    label_size = 2
    ex = 2

    #train_loss = np.empty((num//(batch_size * ex)) * epochs)
    #train_acc = np.empty((num//(batch_size * ex)) * epochs)

    x = tf.placeholder(tf.float32, shape = [None, image_size * image_size])
    y = tf.placeholder(tf.float32, shape = [None, label_size])

    X_train_ = tf.reshape(x, [-1, image_size, image_size, 1])

    #First layer
    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])

    h_conv1 = tf.nn.relu(conv2d(X_train_, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)

    #Second layer
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    #Third layer
    #W_conv3 = weight_variable([5, 5, 64, 128])
    #b_conv3 = bias_variable([128])

    #h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)
    #h_pool3 = max_pool_2x2(h_conv3)

    #Full connect layer
    W_fc1 = weight_variable([64 * 64 * 32, hidden])
    b_fc1 = bias_variable([hidden])

    h_pool2_flat = tf.reshape(h_pool2, [-1, 64 * 64 * 32])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    #Output_Softmax

    W_fc2 = weight_variable([hidden, label_size])
    b_fc2 = bias_variable([label_size])

    y_conv = tf.nn.softmax(tf.matmul(h_fc1, W_fc2) + b_fc2)

    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y, logits = y_conv))
    optimize = tf.train.AdamOptimizer(learning_rate).minimize(loss)
    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y, 1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

And then is the data read or sess section.

About the shape

As the shape of placeholder, if the batch size is 200

X shape: [200, 128 * 128]

label shape: [200, 2]

output shape: [200, 2]

About the output result

I think the predicted value should be trained as [1, 0] or [0, 1], but after about 5 steps, the predicted values are all [1, 0] or [0, 1]. For example, if the batch size is 5, the result will be

[[1, 0],
[1, 0],
[1, 0],
[1, 0],
[1, 0]] 

or completely opposite. However, sometimes result will be different, like this

[[1, 0],
[0, 1],
[1, 0],
[0, 1],
[1, 0]] 

But this only last about 5 steps, then result will be all same.

About the loss and accuracy

Since the predicted result is not right, the loss is not convergent. In other words, the loss and accuracy totally depend on the X of the training dataset, which is unmeaningful.

My thinking

I think the dataset, TFrecords, does not have the problem since I have printed the image matrix and label, they are all right. So I think the problem lies in the model.

I did not get the answer which could solve my question and problem from Google Search and other problems in SO, really thank you if you could help me with this. Please let me know if you need more results or code for the reference.

Answer 1

I think that your data might be unbalanced, ie the numbers of training samples are not roughly for both classes. In your example, you might have much more healthy targets than unhealthy ones. In this case, the loss function is significantly reduced by classifying all samples into the same class, but after this, the misclassified samples are unlikely to be classified correctly again after some time.

You can try to resample your data in order to get roughly equal numbers for both classes.

Another approach is to use a weighted cross entropy (for example, you could compute the cross entropy for each sample, and multiply it with a weight (to be exact, a Tensor of weights for each sample); only after this should you apply tf.reduce_mean . You could, for example, apply a larger weight to the class containing fewer samples, and thus force the optimizer to pay more attention to these samples.

This should look like this:

weights = tf.placeholder(tf.float32, shape=[None])
loss = tf.reduce_mean(tf.multiply(tf.nn.softmax_cross_entropy_with_logits(labels = y, logits = y_conv), weights))

Of course, you need to fill weights with values at some point.