ValueError: cannot reshape array of size 1091 into shape (85)
  • 14-May-2023
Lightrun Team
Author Lightrun Team
ValueError: cannot reshape array of size 1091 into shape (85)

ValueError: cannot reshape array of size 1091 into shape (85)

Lightrun Team
Lightrun Team

Explanation of the problem

Upon cloning the repository and attempting to run the provided demo, an error occurred, resulting in a traceback. The error message suggests that the issue lies within the file at line 191. Specifically, a ValueError is raised when attempting to reshape an array. The array, which has a size of 1091, is being reshaped into the shape (85), causing the error. This error disrupts the execution of the demo and prevents it from running successfully.

To set up the demo, the repository was cloned, and the necessary files, namely coco.names and yolov3.weights, were downloaded. Following that, a series of commands were executed to prepare the environment and run the demo. The script was used to convert the weights into the desired format, using the --data_format NHWC flag. Subsequently, the script was run to generate a frozen model with the same data format specification. Finally, the script was executed, providing input and output image paths, the frozen model file path, and specifying the data format as NHWC. However, the demo script encountered the aforementioned error, leading to the suspicion that the issue might be related to the data format used (NHWC) instead of NCHW.

The error message reads “cannot reshape array of size 5370 into shape (30,256,1,1)”. The user made changes to their configuration file, “”, and executed two scripts with different input arguments. The classes for object detection are specified in the file “obj.names”.

Technical Details:

The user has made changes to the YOLO options in the configuration file, “”. These changes include specifying the object detection classes in “obj.names”, the anchors for YOLO, the strides and XY scales, and the IOU loss threshold. The user has executed two scripts with different input size and model arguments.

The code blocks provided show the execution of the scripts with input arguments specifying the weights file, output location, input size, and model type. The second execution specifies a “tiny” model with input size 416. The obj.names file specifies the classes for object detection.

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: cannot reshape array of size 1091 into shape (85)

One proposed solution involves addressing the error by finding all lines in the code that only contain zeros. Instead of using np.nonzero, an alternative approach is suggested. By calculating the sum of each line using np.sum and identifying the indexes where the sum is not equal to zero, a new array is created. The provided code snippet demonstrates this process, where the temp variable holds the image_pred array, and sum_t stores the sum of each line. The non_zero_idx variable captures the indexes where the sum is not equal to zero. Finally, the image_pred array is updated by selecting only the rows corresponding to these non-zero indexes. This approach aims to resolve the value error and allow the demo to run successfully.

temp = image_pred
sum_t = np.sum(temp, axis=1)
non_zero_idx = sum_t != 0
image_pred = image_pred[non_zero_idx, :]

Another solution involves modifying the file. Within the code, a loop iterates over the predictions, and the shape of image_pred is determined. Previously, the np.nonzero function was used to find the non-zero elements in image_pred, but it caused the value error. The suggested modification replaces this line with the calculation and filtering based on the sum of each line. The image_pred array is reshaped to match the specified shape and ensure compatibility. By applying this modification, it is expected that the error encountered during the demo execution can be resolved.

for i, image_pred in enumerate(predictions):
    shape = image_pred.shape
    temp = image_pred
    sum_t = np.sum(temp, axis=1)
    non_zero_idx = sum_t != 0
    image_pred = image_pred[non_zero_idx, :]
    image_pred = image_pred.reshape(-1, shape[-1])

Other popular problems with hunglc007 tensorflow-yolov4-tflite

Problem: TensorFlow Lite Interpreter Compatibility Issues

The TensorFlow Lite interpreter may not be compatible with the latest version of the YOLOv4 model, causing errors and crashes when running the model.


It is recommended to update to the latest version of the TensorFlow Lite interpreter to ensure compatibility. If that doesn’t work, try downgrading the version of the YOLOv4 model to an earlier version that is compatible with the TensorFlow Lite interpreter.

Problem: Input Shape Mismatch Error

An input shape mismatch error occurs when the shape of the input image passed to the YOLOv4 model does not match the expected shape defined in the model’s configuration file.


Verify that the input image shape matches the expected shape defined in the model’s configuration file, and resize the image if necessary. Also, make sure that the input image is in the correct format, such as RGB or BGR.

Problem: Performance Degradation with Large Model Sizes

The YOLOv4 model may experience performance degradation when the model size is too large, causing slow inference times and high memory usage.


To improve performance, try optimizing the model by reducing the number of parameters and layers, or by using pruning techniques. Another solution is to run the model on hardware that is optimized for deep learning, such as GPUs or TPUs

A brief introduction to hunglc007 tensorflow-yolov4-tflite

hunglc007 tensorflow-yolov4-tflite is an open-source project that implements YOLOv4, a state-of-the-art object detection model, using TensorFlow and TensorFlow Lite. YOLOv4 is a deep learning-based model that can detect objects in real-time with high accuracy. The project is designed to be easy to use, with a focus on fast and efficient object detection for a wide range of use cases, such as security and surveillance, self-driving cars, and image processing.

The implementation of YOLOv4 in hunglc007 tensorflow-yolov4-tflite is optimized for deployment on mobile devices, with the use of TensorFlow Lite. TensorFlow Lite is a lightweight and efficient framework for running deep learning models on resource-constrained devices, such as smartphones and Raspberry Pis. This optimization allows for the deployment of the object detection model in real-time, even on devices with limited computational resources. The project also includes pre-trained weights and example code for object detection, making it easy for developers to get started with object detection using YOLOv4 and TensorFlow Lite.

Most popular use cases for hunglc007 tensorflow-yolov4-tflite

  1. Object Detection in Real-time: hunglc007 tensorflow-yolov4-tflite can be used to detect objects in real-time using a webcam or video feed. The model can be integrated into a computer vision pipeline, allowing for the detection of objects in real-time as the video is being captured.
import cv2
import numpy as np

# Load the TensorFlow Lite model
interpreter = tf.lite.Interpreter(model_path="yolov4.tflite")

# Get input and output tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Open the video capture
cap = cv2.VideoCapture(0)

while True:
    # Capture a frame from the video
    ret, frame =

    # Preprocess the frame for input to the TensorFlow Lite model
    frame = cv2.resize(frame, (416, 416))
    frame = np.expand_dims(frame, axis=0)

    # Run the TensorFlow Lite model
    interpreter.set_tensor(input_details[0]['index'], frame)

    # Get the results from the model
    boxes = interpreter.get_tensor(output_details[0]['index'])
    classes = interpreter.get_tensor(output_details[1]['index'])
    scores = interpreter.get_tensor(output_details[2]['index'])

    # Draw the bounding boxes on the frame
    for i in range(boxes.shape[1]):
        if scores[0, i] > 0.5:
            x1, y1, x2, y2 = boxes[0, i]
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2)

    # Show the frame
    cv2.imshow("Object Detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):

# Release the video capture
  1. Image Classification and Segmentation: In addition to object detection, hunglc007 tensorflow-yolov4-tflite can also be used for image classification and segmentation tasks. The model can be fine-tuned on a specific task or dataset, allowing for highly accurate results in these areas.
  2. Autonomous Systems: hunglc__ tensorflow-yolov4-tflite can be used in autonomous systems, such as self-driving cars, to detect objects in the environment and make decisions based on that information. The ability to run object detection in real-time on resource-constrained devices makes it an ideal choice for deployment in these types of systems.

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.