层“conv2d”的输入 0 与层不兼容：输入形状的预期轴 -1 具有值 1

Question

我正在尝试制作 Cgan，我想在类别之间进行插值，但出现以下错误

“图层“conv2d”的输入 0 与图层不兼容：输入形状的预期轴 -1 具有值 1，但接收到形状为 (128、28、28、11) 的输入

有人可以帮我修复它。

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, BatchNormalization, Dense, Dropout, Flatten, Reshape
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import Conv2D, Conv2DTranspose
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
import tensorflow as tf

import warnings , os
from tensorflow.keras.layers import (Activation, BatchNormalization, Concatenate, Dense,Embedding, Flatten, Input, Multiply, Reshape)
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import Conv2D, Conv2DTranspose
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.optimizers import Adam
from keras.models import load_model
from tensorflow.keras import activations
from tensorflow import keras


#Dimensiones de entrada del modelo
img_rows = 28
img_cols = 28
channels = 1

# Input image dimensions
img_shape = (img_rows, img_cols, channels)
z_dim = 100                                     #Tamaño del vector de ruido, utilizado como entrada al Generador

batch_size = 64
num_channels = 1
num_classes = 10
image_size = 28
latent_dim = 128
img_rows=28
img_cols=28


generator_in_channels = latent_dim + num_classes
discriminator_in_channels = num_channels + num_classes
print(generator_in_channels, discriminator_in_channels)

# Usaremos todos los ejemplos disponibles tanto del entrenamiento como de la prueba conjuntos.
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test]) # une las matrices
all_labels = np.concatenate([y_train, y_test])

# Escale los valores de píxeles al rango [0, 1], agregue una dimensión de canal a
# las imágenes y la codificación one-hot de las etiquetas.
all_digits = all_digits.astype("float32") / 127.5-1.0
All_digits  = np.expand_dims(all_digits, axis=3)
All_digits = np.expand_dims(All_digits, axis=3)
all_digits = np.reshape(all_digits, (-1, 28, 28, 1)) #tal cual remodela o reacomoda
all_labels = keras.utils.to_categorical(all_labels, 10) #Convierte un vector de clase (enteros) en una matriz de clase binaria.



# Crear tf.data.Dataset.
dataset = tf.data.Dataset.from_tensor_slices((all_digits, all_labels))
dataset = dataset.shuffle(buffer_size=1024).batch(batch_size) # este es llamado en cond_gan.fit
print(dataset)

print(f"Shape of training images: {all_digits.shape}")
print(f"Shape of training labels: {all_labels.shape}")


#DCGAN Generator
def build_generator(generator_in_channels):

    model = Sequential() #modelo es apropiado para una simple pila de capas donde cada capa tiene exactamente un tensor de entrada y un tensor de salida
    model.add(Dense(256 * 7 * 7, input_dim=generator_in_channels))
    model.add(Reshape((7, 7, 256)))
    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh')) 

    return model
#DCGAN Discriminator
def build_discriminator(img_shape):
    model = Sequential()
    #model.add(keras.Input(shape=(28, 28, discriminator_in_channels)))
    model.add(Conv2D(32,kernel_size=3,strides=2,padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(64,kernel_size=3,strides=2,padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(128,kernel_size=3,strides=2,padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

def build_gan(generator, discriminator):
    model = Sequential()

    # Genearator -> Discriminator
    model.add(generator)
    model.add(discriminator)

    return model


# Creación y compilación de modelos discriminadores
discriminator = build_discriminator(img_shape)
discriminator.compile(loss='binary_crossentropy',optimizer=Adam(), metrics=['accuracy'])
# Preserve los parámetros del discriminador mientras entrena al generador
discriminator.trainable = False

# Crear un modelo generador
generator = build_generator(generator_in_channels)

# Cree y compile un modelo GAN con discriminadores congelados para entrenar al generador
gan = build_gan(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam())


from operator import ge
losses = []
accuracies = []
iteration_checkpoints = []

def train(data,iterations, batch_size, sample_interval):
    # Cargar conjunto de datos MNIST
    #data = data.window(2)
    #windows = next(iter(data))
    #real_images, one_hot_labels=windows
    #print(real_images)
    #print(type(real_images))
    for iteration in range(iterations):    
        iterator = iter(data)

        # get x and y
        real_images, one_hot_labels = iterator.get_next()
        real_images=tf.constant(real_images)
      

        # Add dummy dimensions to the labels so that they can be concatenated with
         # the images. This is for the discriminator.
        image_one_hot_labels = one_hot_labels[:, :, None, None]
        image_one_hot_labels = tf.repeat( image_one_hot_labels, repeats=[image_size * image_size])
        image_one_hot_labels = tf.reshape( image_one_hot_labels, (-1, image_size, image_size, num_classes))

       # Etiqueta de imagen real: All 1
        real = np.ones((batch_size, 1)) ##------------

        # Etiquetas de imágenes falsas: Todas 0
        fake = np.zeros((batch_size, 1)) ##------------

   
        # -------------------------
        #  Entrenamiento discriminatorio
        # -------------------------

        # This is for the generator.
        batch_size = tf.shape(real_images)[0]
        random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim))
        random_vector_labels = tf.concat( [random_latent_vectors, one_hot_labels], axis=1)
    
        # Decode the noise (guided by labels) to fake images.
        generated_images = generator(random_vector_labels)

        # Obtenga lotes aleatorios de imágenes reales
        idx = np.random.randint(0, All_digits.shape[0], batch_size) ##------------
        imgs = All_digits[idx] ##------------

        # Crear lotes de imágenes falsas
        z = np.random.normal(0, 1, (batch_size, generator_in_channels)) ##------------
        gen_imgs = generator.predict(z) ##------------
        
        # Combínalos con imágenes reales. Tenga en cuenta que estamos concatenando las etiquetas con estas imágenes aquí.
        fake_image_and_labels = tf.concat([gen_imgs, image_one_hot_labels], -1)
        real_image_and_labels = tf.concat([real_images, image_one_hot_labels], -1)
        combined_images = tf.concat([fake_image_and_labels, real_image_and_labels], axis=0 )


        # Training
         
        #d_loss_real = discriminator.train_on_batch(imgs, real) ##------------
        #d_loss_fake = discriminator.train_on_batch(fake_image_and_labels, fake) ##------------
        #print(d_loss_fake)
        #print(type(d_loss_fake))
        #d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake) ##------------
        
        # Reúna etiquetas que distingan las imágenes reales de las falsas.
        labels = tf.concat( [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0 )


        #-------d_losss
        print('hola1')
        predictions = discriminator(combined_images)
        print('hola2')

        # ---------------------
        #  Training generator
        # ---------------------
        
        # Crear lotes de imágenes falsas
        
        z = np.random.normal(0, 1, (batch_size, generator_in_channels)) ##------------
        gen_imgs = generator.predict(z)##------------
        
        if iteration == 0: ##------------ 
            print("\nRandom noise input image") ##------------
            sample_images(generator)        ##------------     

        g_loss = gan.train_on_batch(z, real) ##------------

        if iteration < 200 and (iteration + 1) % 20 == 0: ##------------
            # Ahorre pérdida y precisión para trazar gráficos después del entrenamiento
            losses.append((d_loss, g_loss)) ##------------
            accuracies.append(100.0 * accuracy) ##------------
            iteration_checkpoints.append(iteration + 1) ##------------

            print("%d [D loss: %f, accuracy: %.2f%%] [G loss: %f]" % ##------------
                  (iteration + 1, d_loss, 100.0 * accuracy, g_loss)) ##------------

            # Salida de muestra de imagen generada
            sample_images(generator) ##------------
            
        elif (iteration + 1) % sample_interval == 0:##------------
            #Ahorre pérdida y precisión para trazar gráficos después del entrenamiento
            losses.append((d_loss, g_loss)) ##------------
            accuracies.append(100.0 * accuracy) ##------------
            iteration_checkpoints.append(iteration + 1) ##------------

            print("%d [D loss: %f, accuracy: %.2f%%] [G loss: %f]" %
                  (iteration + 1, d_loss, 100.0 * accuracy, g_loss)) ##------------

            # Salida de muestra de imagen generada
            sample_images(generator)##------------

def sample_images(generator, image_grid_rows=5, image_grid_columns=5):

    # muestreo de ruido aleatorio
    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, generator_in_channels))
    
    # Generar imagen a partir de ruido aleatorio
    gen_imgs = generator.predict(z)
    
    # Escala los valores de píxeles de la imagen entre [0, 1]
    gen_imgs = 0.5 * gen_imgs + 0.5
    
    plt.figure(figsize=(6,4))
    sns.distplot(gen_imgs,color='blue',kde=True)
    plt.title("Generated Images Distribution")
    plt.show()

    fig, axs = plt.subplots(image_grid_rows,
                            image_grid_columns,
                            figsize=(7, 7),
                            sharey=True,
                            sharex=True)

    cnt = 0
    plt.figure(figsize=(9,9))
    for i in range(image_grid_rows):
        for j in range(image_grid_columns):
            axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
            axs[i, j].axis('off')
            cnt += 1
    plt.show()
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#    axs[1, 1].imshow(gen_imgs[2, :, :, 0], cmap='gray')
#    axs[1, 1].axis('off')
#plt.show()

#Listing 4.8 Running the model
iterations = 20000 #Establece hiperparámetros
batch_size = 64
sample_interval = 1000 #Entrena el DCGAN para el número especificado de iteraciones
train(dataset,iterations, batch_size, sample_interval) 

我不是专家，我正在尝试加入两个代码以实现我的目标