如何修复：ValueError：检查输入时出错：预期 conv2d_130_input 具有形状 (1, 512, 512) 但得到形状为 (79, 512, 512) 的数组

Question

I am a beginner at working with CNNs.

So, I am building a 2D convolutional neural network that predicts brain tumor type and have a question about NumPy arrays. The input-shape of my model is (1, 512, 512) as (channels, img_height, img_width). The 4th dimension is num_images which seems to be automatically defined by TensorFlow. This is just a quick background. I have 3064 ".mat" extension files with MRI scans of brain tumors. Everything is setup. I converted ".mat" files into numpy matrices and appended the entire list of matrices in a single numpy array to pass as input for the CNN. I also have the corresponding labels (index-linked to the images when passing input into the model) as a numpy array. All the numbers are of float type in both images and labels.

Again, my input shape is (1, 512, 512). However, when fitting my model I get the following error:

ValueError: Error when checking input: expected conv2d_130_input to have shape (1, 512, 512) but got array with shape (79, 512, 512)

So, I am slicing my NumPy arrays to create train_images, train_labels, test_images, test_labels. I have verified the length of each both train and test sets with there labels match. They are also arrays, I checked multiple times. And this is a value error. So, how do I fix this?

I don't even know where the input shape became (79,512,512). I have a loop to convert f"{n}.mat" images to a matrix. I am using 100 images to test and have 80 train and 20 test. I think the mistake is here, the input shape is (channels, img-hght, img-wdth), but the number of images left to train is being placed in the channel's value instead. So, the input is being placed as (num_images, img-hght, img-wdth). This is wrong and should be changed, but I don't know how to do it. Or, I could be wrong and what I said might not make sense. I am providing all the code, running it on Colab. Make sure to change the image paths if you download the code and want to run it in order to help me out. Thanks a lot!

Dataset: https://figshare.com/articles/brain_tumor_dataset/1512427/5

#Importing the necessary libraries through PIP to the Virtual Environment
try:
  !python -m pip install --upgrade pip #Quickly update PIP to latest version
  !python -m pip install pymatreader
  !python -m pip install pyswarm #An interesting library for testing purposes
  print("""
The following libraries are available and have been successfully fetched:
  >>> PyMatReader
  >>> Particle Swarm""")
except Exception:
  print("""
The following libraries have unavailable and have not been fetched:
  >>> PyMatReader
  >>> Particle Swarm""")
  pass

#Importing the necessary libraries to the Virtual Environment
from __future__ import absolute_import, division, print_function, unicode_literals
import random as rnd
from random import shuffle
import numpy as np
import sys
import scipy as sp
from scipy.ndimage import gaussian_filter
import pymatreader as pym
import pandas as pd
import seaborn as sns
import matplotlib as mpl
import matplotlib.image as mplimg
import matplotlib.pyplot as plt
import PIL
from PIL import Image
import imageio
import sklearn as sk
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import image
import sklearn.metrics as skm

print("""
The following libraries have been successfully imported:
  >>> Future
  >>> Random (with shuffle)
  >>> NumPy
  >>> System
  >>> SciPy (with gaussian filter)
  >>> PyMatReader
  >>> Pandas
  >>> Seaborn
  >>> Matplotlib (with PyPlot & Image)
  >>> PIL (with Image)
  >>> Imageio
  >>> Sci-Kit Learn (with metrics & train_test_split)
  >>> Sci-kit Learn Feature Extraction (with Image)
""")

try:
  %tensorflow_version 2.x
  import keras
  import tensorflow as tf
  print("TensorFlow version 2.x is available and has been successfully imported.")
except Exception:
  %tensorflow_version 1.x
  import keras
  import tensorflow as tf
  print("TensorFlow version 2.x is unavailable. TensorFlow version 1.x has been imported instead.")
  pass

from tensorflow.keras import datasets, layers, models
import keras.preprocessing
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D
from keras.optimizers import Adam
import pyswarm
from pyswarm import pso

autoTune = tf.data.experimental.AUTOTUNE

print("""
The following deep learning optimizers have been successfully imported:
  >>> Adam
  >>> Particle Swarm (with pso)
""")

print("All libraries have been successfully imported.")

#Understanding the Image Data using Seaborn and Matplotlib
classNames = {1 : "Meningioma", 2 : "Glioma", 3 : "Pituitary Tumor", 4 : "Unkown", 5 : "Unkown"}
outputSize = len(classNames)

chooseImgNum = 2978
example = pym.read_mat(f'/content/gdrive/My Drive/My Files/Neuroimaging/Neuroimaging Datasets/MATLAB Files/{chooseImgNum}.mat')
cjdata = example['cjdata']
pid = cjdata['PID']
img = cjdata['image']
label = cjdata['label']

tumorBorder = cjdata['tumorBorder']
tumorMask = cjdata['tumorMask']
print("Tumor Border is: \n", tumorBorder, "\n")
print("Tumor Mask is: \n", tumorMask, "\n")

def printImage():
  plt.figure(figsize=(5, 5))
  plt.imshow(img, cmap=None)

def matrixConv(): #Data Visualization only
  matrix = np.asmatrix(tumorBorder)
  plt.figure(figsize=(5, 5))
  return matrix

def applyGrayscale():
  plt.figure(figsize=(5, 5))
  plt.imshow(img, cmap='gray')

print("""
      Below is the original image followed by a grayscale application:
____________________________________________________________________________
""")

printImage()
applyGrayscale()

#Preprocessing Brain Images from Dataset
range1 = np.arange(0, 100)
imgMatrices = []
imgNum = 1
i = 1

while imgNum in range1:
  imgNum = pym.read_mat(f'/content/gdrive/My Drive/My Files/Neuroimaging/Neuroimaging Datasets/MATLAB Files/{imgNum}.mat')
  cjdata = imgNum['cjdata']
  imgMatrix = cjdata['image']
  # plt.figure(figsize=(5, 5))
  # plt.imshow(image_matrix, cmap='gray')
  imgMatrixNP = np.asmatrix(imgMatrix)
  imgArrayNP = np.asarray(imgMatrixNP)
  imgMatrices.append(imgArrayNP)
  imgNum = i
  i = i + 1

print("The length of the image input list is:", len(imgMatrices))

imgMatricesNP = np.asarray(imgMatrices)
print("The length of the converted image input array is:", len(imgMatricesNP), "\n")

print("The image input array:")
imgMatricesNP #Prints the raw array

#Supervised Learning: Understanding Cancer Type labels
np.set_printoptions(threshold=3)
#np.set_printoptions(threshold=sys.maxsize) #To check the content of the entire array

rawMatData = pym.read_mat('/content/gdrive/My Drive/My Files/Neuroimaging/Neuroimaging Datasets/cvind.mat')
print("Labels file in \".mat\" format converted to dictionary format:", rawMatData)

matDataList = list(rawMatData.values())
print("Labels converted to list format:", matDataList)

matDataArray = np.asarray(matDataList)
print("Labels converted to array format:", matDataArray, "\n")
shapedMatDataArray = matDataArray.reshape(-1, 3064, 1)
print("Reshaped labels in array format:\n", shapedMatDataArray, "\n")

matData = pd.DataFrame(matDataArray)
print("Labels converted to a Pandas DataFrame:")
matData #Prints out the DataFrame

#Viewing labels based on image number
def imgLabelCheck(n):
  callback = matData.at[0, n-1]
  print(f"Image Number {n} has the following Cancer Type: {classNames[callback]}.")
  return

pickImg = 1 #Choose an image number to look for its Cancer Type
imgLabelCheck(pickImg)

#Preparing the Datasets: Looping Train Set & Test Set
print("___________________________________________________________________________________\n")

train_images = np.array([imgMatricesNP[0:79]])
print("Training images range is:\n", train_images, "\n")

uppTrBn = len(train_images)
loqTrRng = 0
uppTrRng = 79
train_labels = np.asarray(matData.loc[:, loqTrRng:uppTrRng], dtype=float, order='A')
print("Training labels range is:", train_labels)

print("___________________________________________________________________________________\n")

test_images = np.array([imgMatricesNP[80:100]])
print("Testing images range is: \n", test_images, "\n")

uppTsBn = len(test_images)
loqTsRng = 80
uppTsRng = 100
test_labels = np.asarray(matData.loc[:, loqTsRng:uppTsRng], dtype=float, order='A')
print("Testing labels range is:", test_labels)

print("___________________________________________________________________________________")
#train_labels #Verify if the ranges are in fact NumPy arrays
#test_labels

#Defining the Convolutional Neural Network
model = models.Sequential()

model.add(layers.Conv2D(512, (3, 3), activation='relu', data_format="channels_first", input_shape=(1, 512, 512))) #The Input Layer
#model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 1
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional Layer 1
model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 2
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional Layer 2
#model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 3
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional Layer 3
model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 4
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional layer 4
#model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 5
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional Layer 5
model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.MaxPooling2D((2, 2), padding='same')) #MaxPooling Layer 6
model.add(layers.Conv2D(1024, (3, 3), activation='relu', padding='same')) #Hidden Convolutional Layer 6
#model.add(layers.Dropout(0.5, noise_shape=None, seed=None)) #Optional Dropout Layer

model.add(layers.Flatten()) #The Flattening Layer

model.add(layers.Dense(512, activation='relu')) #Dense Layer 1
model.add(layers.Dense(256, activation='relu')) #Dense Layer 2
model.add(layers.Dense(128, activation='relu')) #Dense Layer 3
model.add(layers.Dense(64, activation='relu')) #Dense Layer 4
model.add(layers.Dense(32, activation='relu')) #Dense Layer 5
model.add(layers.Dense(16, activation='relu')) #Dense Layer 6

model.add(layers.Dense(outputSize, activation='softmax')) #The Output Layer

model.summary()

#Compiling the Convolutional Neural Network with an Optimizer
#The Adam Optimizer is ideal for biological image classification.
#The Optimizer automatically performs forward and backward propagation.

model.compile(
    optimizer='Adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights=None,
    sample_weight_mode=None,
    weighted_metrics=None,
    target_tensors=None
  )

print("The Neuroimaging Model has been successfully compiled.")

#Training the Convolutional Neural Network
history = model.fit(train_images, train_labels, epochs=10, batch_size=1, verbose=1,
                    validation_data=(test_images, test_labels))

print("\nThe Neuroimaging Model has been successfully trained.")

Each code box on this page represents a single code cell for Colab or Jupyter notebook. Once again, all help is welcome and appreciated! (The model is not fully built, but layers are added for experimentation only.

Answer 1

Add the line:

train_images = np.reshape(train_images, (-1,1,512,512))

after the below line in your code

train_images = np.array([imgMatricesNP[0:79]])

to get the individual images' input_shape=(1, 512, 512) instead of (79, 512, 512) because the model is expecting an input shape of (1, 1, 512, 512) (according to the dimensions (batch_size, channels, height, width) ) while your current code provides an input shape of (1, 79, 512, 512) . If you have sufficient compute resources, increase the batch_size to 8 (say), so that your total input shape would be (8, 1, 512, 512) .

Also, perform a similar operation on test_images :

test_images = np.reshape(test_images, (-1,1,512,512))

after the line:

test_images = np.array([imgMatricesNP[80:100]])

PS: Also, it seems that your intent is to slice the first 80 images from the input imgMatricesNP . However, with imgMatricesNP[0:79] , you only get the first 79 images (as the last index of a slice is excluded in Python). So, the correction would be:

train_images = np.array([imgMatricesNP[0:80]])

and assign uppTrRng=80 .

Hope this helps! :)