This article is about fixing ValueError could not broadcast input array from shape (96,96,4) into shape (96,96) in carpedm20 DCGAN Tensorflow
  • 30-Jan-2023
Lightrun Team
Author Lightrun Team
This article is about fixing ValueError could not broadcast input array from shape (96,96,4) into shape (96,96) in carpedm20 DCGAN Tensorflow

ValueError: could not broadcast input array from shape (96,96,4) into shape (96,96) in carpedm20 DCGAN Tensorflow

Lightrun Team
Lightrun Team

Explanation of the problem

The user is encountering an issue with their image dataset while training a GAN using TensorFlow. They are using their own image dataset, all scaled to 96×96 in PNG format. The user is unsure if they are doing something wrong or if there’s a fix available.

The user provides the information of the PNG image used in the dataset. The image is 96×96 in size and has 8-bit sRGB color depth. The size of the image is 7.2KB.

Image Information: PNG 96×96 96×96+0+0 8-bit sRGB 7.2KB 0.000u 0:00.000

Stack Trace: The user provides a stack trace of the error they encountered while training the GAN. The error occurs in the file on line 99 and the function call that throws the error is The error is caught in the file on line 186, where the sample input is being converted to a numpy array of type float32.

Code Snippet:

Traceback (most recent call last):
  File "", line 99, in <module>
  File "/home/ubuntu/.local/lib/python2.7/site-packages/tensorflow/python/platform/", line 44, in run
    _sys.exit(main(_sys.argv[:1] + flags_passthrough))
  File "", line 82, in main
  File "/home/ubuntu/GANs/", line 186, in train
    sample_inputs = np.array(sample).astype(np.float32)

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for ValueError: could not broadcast input array from shape (96,96,4) into shape (96,96) in carpedm20 DCGAN Tensorflow

The issue at hand is related to working with image datasets in computer vision projects. It appears that some of the images in the dataset are causing problems, either due to being grayscale or having a different size than the other images. These differences can cause issues when working with the images in the dataset, as some algorithms expect a certain format or size for the images they are processing.

The first solution proposes converting grayscale images to RGB images. This is done by using the Python Imaging Library (PIL) and the convert method. The following code demonstrates how this can be done:

from PIL import Image
img ='RGB')
# your own image operations 

The second solution addresses the issue of having images with different sizes in the dataset. The solution proposed is to use the identify tool from Imagemagick to identify the images that do not match the desired size and move them to a separate directory. This can be done as follows:

cd data/mypics
# Create dir to store images that aren't the same size`
mkdir misshaped
# Identify misshaped images using Imagemagick's 'identify' tool 
and move to above dir. (Replace with your desired resolution)
identify * | grep -v "600x450" | awk '{ print $1 }' | xargs -I {} bash -c "mv {} misshaped"

In addition to size, the solution also addresses the issue of having images with different numbers of colors in the dataset. This can be done by using the identify tool with the -format option and searching for images that do not have the desired colorspace. The following code demonstrates this:

identify -format "%i %[colorspace]\n" IMG_*.jpg | grep -v sRGB
IMG_4959.jpg Gray
IMG_4960.jpg Gray
IMG_4961.jpg Gray
IMG_4962.jpg Gray
IMG_7356.jpg Gray
IMG_7630.jpg Gray

By addressing these issues with the image dataset, it should allow for smoother and more accurate processing of the images in computer vision projects.

Other popular problems with DCGAN Tensorflow

Problem: Inconsistent Latent Space Inputs

One of the most common issues with training DCGANs using Tensorflow is inconsistent latent space inputs. The DCGAN architecture generates images from a random noise vector, also known as the latent space, which is fed into the generator. If the latent space inputs are not consistent in terms of size, shape or distribution, the generator will struggle to produce meaningful outputs.


To overcome this issue, it is crucial to ensure that the latent space inputs are sampled from a consistent distribution, such as a normal or uniform distribution. A common solution is to use the tf.keras.layers.Input layer to specify the input shape and use the tf.random module to sample the latent space inputs.

latent_dim = 100

inputs = tf.keras.layers.Input(shape=(latent_dim,))

z = tf.random.normal(shape=(batch_size, latent_dim))

generator_inputs = tf.keras.layers.Input(shape=(latent_dim,))

Problem: Generator Overfitting

Another common problem with DCGANs in Tensorflow is the generator overfitting, where the generator produces images that are too similar to the training data and fail to capture the underlying distribution of the target data. This can result in the generated images looking unrealistic and lacking diversity.


To mitigate this issue, several techniques can be employed, such as using dropout layers in the generator or using data augmentation techniques such as flipping, rotation, or scaling. Another solution is to use a combination of L1 and L2 regularization to penalize the generator for producing outputs that deviate too much from the target data distribution.

generator = tf.keras.models.Sequential([
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(1024, activation='relu'),
    tf.keras.layers.Dense(, activation='tanh')

generator.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(1e-4))

Problem: Mode Collapse

Another common issue with DCGANs is mode collapse, which occurs when the generator produces only a limited number of outputs instead of diverse outputs, resulting in a reduced variety in the generated images. The problem is caused by the training process, where the generator updates its parameters to minimize the loss function between the generated images and the real images, but it may learn to generate the same image multiple times to trick the discriminator.


One way to mitigate mode collapse is to enforce diversity in the loss function. This can be achieved by adding a term that encourages the generator to produce diverse outputs, such as the L1 or L2 distance between generated images, or the L2 norm of the gradient of the output with respect to the input noise. For example, the following code block shows how to add a diversity term to the loss function in TensorFlow:

# L2 distance between generated images
diversity_loss = tf.reduce_mean(tf.square(generated_images[0] - generated_images[1]))
# total loss for the generator
total_loss = generator_loss + diversity_loss

A brief introduction to DCGAN Tensorflow

DCGAN (Deep Convolutional Generative Adversarial Networks) is a variant of Generative Adversarial Networks (GANs) that uses convolutional layers in the generator and discriminator instead of fully connected layers. DCGANs are used for generating new images from a given dataset, by training on a large number of real images. The generator is trained to generate new images that are similar to the real images, while the discriminator is trained to distinguish between real and generated images.

In Tensorflow, the implementation of DCGAN involves defining the generator and discriminator models using the Tensorflow Keras API. The generator model uses a series of transposed convolutional layers to upsample a random noise vector and produce an image. The discriminator model uses a series of convolutional layers and Leaky ReLU activation functions to determine if an image is real or generated. The training process involves alternating between training the generator and discriminator, where the generator tries to generate images that can fool the discriminator, and the discriminator tries to correctly identify real and generated images. This process continues until the generator is able to generate high-quality images that are indistinguishable from real images.

Most popular use cases for DCGAN Tensorflow

  1. Generating new images: DCGAN Tensorflow can be used to generate new, synthetic images that are similar in style to a training dataset. This is done by training a deep convolutional generative adversarial network (DCGAN) to learn the patterns and features of the training data, and then using this learned information to generate new images from random noise. The following code block shows how to define the generator architecture in Tensorflow:
def make_generator_model():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))

    model.add(layers.Reshape((7, 7, 256)))
    assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size

    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    assert model.output_shape == (None, 7, 7, 128)

    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    assert model.output_shape == (None, 14, 14, 64)

    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    assert model.output_shape == (None, 28, 28, 1)

    return model
  1. Image transformation: DCGAN Tensorflow can also be used to transform an input image into a new image with a different style or attribute. This is done by training a DCGAN to learn the patterns and features of the desired output style, and then using this learned information to modify the input image. This approach can be used for tasks such as style transfer, super-resolution, and denoising.
  2. Data augmentation: DCGAN Tensorflow can also be used for data augmentation in machine learning tasks. By generating new, synthetic images from the training data, DCGANs can provide a larger and more diverse training dataset, which can improve model performance and reduce overfitting. This approach can be especially useful for tasks where the training data is limited or imbalanced.

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.