CNN 的准确率非常低

Question

I am learning about neural networks and trying to build my own CNN model from scratch. Currently I'm working on the Stanford Dog Dataset with 20000 pictures. I already built a model and getting already low cost. But the accuracy is very low, I can't understand the reason though.

Here I do data augmentation:

import os
import time
import zipfile
import pandas as pd
import tensorflow as tf
from tensorflow import keras # Tensorflow high-level api
from tensorflow.keras import layers

from keras import optimizers
from keras.models import Model, Sequential
from keras.layers import Dense,Flatten, GlobalAveragePooling2D, BatchNormalization, Activation, Dropout, Conv2D,MaxPooling2D
from keras.callbacks import ModelCheckpoint, EarlyStopping, TensorBoard, CSVLogger, ReduceLROnPlateau
#from keras.layers import Activation, Dropout, Flatten, Dense
from keras.applications.xception import Xception
from keras.preprocessing.image import ImageDataGenerator

!pip install kaggle
from google.colab import files
files.upload()

#before importing the dataset we want to use this code
# The Kaggle API client expects this file to be in ~/.kaggle,
!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/

# This permissions change avoids a warning on Kaggle tool startup.
!chmod 600 ~/.kaggle/kaggle.json

!kaggle datasets download -d jessicali9530/stanford-dogs-dataset

local_zip = '/content/stanford-dogs-dataset.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/content/stanford-dogs')
zip_ref.close()


train_data_dir = os.path.join("/content", "stanford-dogs", "images", "Images")
img_width, img_height = 128, 128
batch_size = 32

train_datagen = ImageDataGenerator(
    rescale=1./255,             
    vertical_flip = True,
    horizontal_flip = True,
    rotation_range=20,
    shear_range=0.05,           
    zoom_range=0.2,   
    width_shift_range=0.1,
    height_shift_range=0.1,
    validation_split=0.15
    channel_shift_range=0.1
 )

train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='categorical',    # 2D one-hot encoded labels (batch_size x 101)
    subset='training')
    
validation_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='categorical',    # 2D one-hot encoded labels (batch_size x 101)
    subset='validation')

 model.add(Conv2D(kernel_size=(3,3),filters=32,input_shape = (img_width, img_height, 3),activation="relu",padding="valid"))

model.add(Conv2D(kernel_size=(3,3),filters=32,activation="relu",padding="same"))
model.add(Dropout(0.15))

model.add(Conv2D(kernel_size=(3,3),filters=24))
model.add(Conv2D(kernel_size=(3,3),filters=64,activation="relu",padding="same"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(kernel_size=(3,3),filters=24))
model.add(Dropout(0.25))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(kernel_size=(5,5),filters=32,activation="relu",padding="same"))

model.add(MaxPooling2D(pool_size=(3,3)))


model.add(Flatten())
model.add(Dense(100,activation="relu",kernel_regularizer=keras.regularizers.l2(0.01)))
model.add(Dropout(0.4))
model.add(Dense(120,activation="softmax"))


model.summary()

model.compile(loss=keras.losses.binary_crossentropy,
           optimizer=keras.optimizers.Adadelta(lr=0.01),
           metrics=['accuracy'])

history = model.fit_generator(train_generator,
       steps_per_epoch = train_generator.n // train_generator.batch_size,
       validation_data = validation_generator,
       validation_steps = validation_generator.n // validation_generator.batch_size,
       epochs = 10,
       shuffle= True,         
       verbose = 1)

The cost is on an expected level, it starts with 1.9 and goes down like I want it to. But I am not sure what to do about the accuracy.

Edit: I edited the code, I'm running it currently on Google Colab.

Answer 1

There are multiple inconsistencies in your model.

1. model.add(Dense(120,activation="softmax")) - this line sugggests you've 120 classes, 120 classes is a lot, the expected randomized accuracy for 120 classes = 0.83 % You need good amount of samples per class.

You most probably need a better model. Also, you need to show the loss and metrics per epoch to get a better idea.

2. If we use softmax for multi-class classification, the preferred loss function is categorical_crossentropy

Answer 2

Your code is not using the correct loss function because the final classification is multiclass (there's more than two types of dog in the dataset's annotations). The keras docs state the following about BinaryCrossentropy :

Use this cross-entropy loss when there are only two label classes (assumed to be 0 and 1). For each example, there should be a single floating-point value per prediction.

You need to use CategoricalCrossentropy . From the docs :

Use this crossentropy loss function when there are two or more label classes. We expect labels to be provided in a one_hot representation. If you want to provide labels as integers, please use SparseCategoricalCrossentropy loss. There should be # classes floating point values per feature.