为什么我的keras模型总是预测相同的结果？

Question

I realize this question has been asked before, but none of those solutions seem to be relevant to my problem.

I am trying to implement a basic binary classification algorithm using logistic regression to identify whether an image is a cat or a dog.

I believe I am structuring the data properly, I am adding a flatten layer before the initial dense layer which I believe is accepting the proper shape, then I run it through two more dense layers with the final one having only 2 outputs (which as I understand it, is the way it should be for a binary classification such as this).

Please take a look at my code and advise what I can do better to:

1.) Make the prediction output vary (not always choose one or the other)
2.) Make my accuracy and loss vary after the second epoch.

I have tried: - varying the number of dense layers and their parameters
- changing the size of my dataset (hence the count variable when processing files)
- changing the number of epochs
- changing the kind model from sgd to adam

dataset initialization

import numpy as np
import cv2
import os
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import random
import keras

dataDir = '/content/gdrive/My Drive/AI'
categories = ['dog', 'cat']

x, y = [], []

imgSize = 100

for cat in categories:
  folderPath = os.path.join(dataDir, cat) # path to the respective folders
  classNum = categories.index(cat)        # sets classification number (0 = dog, 1 = cat)
  count = 0                               # used for limiting the number of images to test
  for file in os.listdir(folderPath):
    count = count + 1                     
    try:
      # open image and convert to grayscale
      img = cv2.imread(os.path.join(folderPath, file), cv2.IMREAD_GRAYSCALE)

      # resize to a square of predefined dimensions
      newImg = cv2.resize(img, (imgSize, imgSize))

      # add images to x and labels to y
      x.append(newImg)
      y.append(classNum)
      if count >= 100:
        break;

    # some images may be broken
    except Exception as e:
      pass

# y array to categorical
y = keras.utils.to_categorical(y, num_classes=2)

# shuffle data to increase training
random.shuffle(x)
random.shuffle(y)

x = np.array(x).reshape(-1, imgSize, imgSize, 1)
y = np.array(y)

# split data into default sized groups (75% train, 25% test)
xTrain, xTest, yTrain, yTest = train_test_split(x, y, test_size=0.25)

# display bar chart
objects = ('xTrain', 'xTest', 'yTrain', 'yTest')
y_pos = np.arange(len(objects))
maxItems = int((len(x) / 2 ) + 1)
arrays = [len(xTrain), len(xTest), len(yTrain), len(yTest)]

plt.bar(y_pos, arrays, align='center')
plt.xticks(y_pos, objects)
plt.ylabel('# of items')
plt.title('Items in Arrays')

plt.show()

model setup

from keras.layers import Dense, Flatten
from keras.models import Sequential

shape = xTest.shape
model = Sequential([Flatten(),
                   Dense(100, activation = 'relu', input_shape = shape),
                   Dense(50, activation = 'relu'),
                   Dense(2, activation = 'softmax')])

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

model.fit(xTrain, yTrain,
         epochs=3,
         verbose=1,
         validation_data=(xTest, yTest))

model.summary()

which outputs:

Train on 150 samples, validate on 50 samples
Epoch 1/3
150/150 [==============================] - 1s 6ms/step - loss: 7.3177 - acc: 0.5400 - val_loss: 1.9236 - val_acc: 0.8800
Epoch 2/3
150/150 [==============================] - 0s 424us/step - loss: 3.4198 - acc: 0.7867 - val_loss: 1.9236 - val_acc: 0.8800
Epoch 3/3
150/150 [==============================] - 0s 430us/step - loss: 3.4198 - acc: 0.7867 - val_loss: 1.9236 - val_acc: 0.8800
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
flatten_13 (Flatten)         (None, 10000)             0         
_________________________________________________________________
dense_45 (Dense)             (None, 100)               1000100   
_________________________________________________________________
dense_46 (Dense)             (None, 50)                5050      
_________________________________________________________________
dense_47 (Dense)             (None, 2)                 102       
=================================================================
Total params: 1,005,252
Trainable params: 1,005,252
Non-trainable params: 0

prediction

y_pred = model.predict(xTest)

for y in y_pred:
  print(y)

which outputs:

[1. 0.]
[1. 0.]
[1. 0.]
.
.
.
[1. 0.]

Answer 1

There are few ways to skin this cat...ha puns. I don't know if yours is working though. So assuming your data and labelings are correct then it's your data collection and model construction that I think are the problems.

First, I don't think you have enough data. Most of these binary classification models are built on >1000 pictures. You're working with a lot less. Second, you're only doing 3 epochs, that's not enough at all. For the amount of pictures you'd need, I'd suggest at least 50 epochs. But that's trial and error to determine the right number and if you're overfitting.

This is what I'd use to construct a model for binary classification.

from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Activation
from keras.optimizers import SGD
from keras.layers import Dense
from keras.utils import np_utils
import numpy as np
import cv2


data = []
labels = []
imageSize = 32
# Do whatever you gotta do to create a folder of flatten/resized images
# and another labels list with indexes that match the index of pitcure
for image in folder:
    imagePath = 'path/to/image/'
    imageLabel = 'whatever_label'
    image = cv2.imread(imagePath)
    features = cv2.resize(image, imageSize).flatten(image)
    data.append(features)
    labels.append(imageLabel)

# Encode the labels
labelEncoder = LabelEncoder()
labels = labelEncoder.fit_transforma(labels)

# Scale the image to [0, 1]
data = np.array(data) / 255.0
# Generate labels as [0, 1] instead of ['dog', 'cat']
labels = np_utils.to_categorical(labels, 2)

# Split data
(trainData, testData, trainLabels, testLabels) = train_test_split(data, labels, test_size = 0.25, random_state = 42)

# Construct Model
model = Sequential()
model.add(Dense(768, input_dim = imageSize * imageSize * 3, init = 'uniform', activation = 'relu'))
model.add(Dense(384, activation = 'relu', kernel_initializer = 'uniform'))
model.add(Dense(2))
model.add(Activation('softmax'))

# Compile
sgd = SGD(lr=0.01)
model.compile(loss = 'binary_crossentropy', optimizer = sgd, metrics = ['accuracy'])
model.fit(trainData, trainLabels, epochs = 50, batch_size = 128, verbose = 1)

# Determine Accuracy and loss
(loss, accuracy) = model.evaluate(testData, testLabels, batch_size = 128, verbose = 1)
print('[INFO] loss={:.4f}, accuracy: {:.4f}%'.format(loss, accuracy * 100))

Hope that helps!