title: cannot reshape array of size 1665179 into shape (512,512,3,3)
body: <p>The script used to do detection. </p>
  
  <p>Weight file was yolov4 coco pre-trained model and that can be found over here.(<a href="https://drive.google.com/file/d/1cewMfusmPjYWbrnuJRuKhPMwRe_b9PaT/view" rel="nofollow noreferrer">https://drive.google.com/file/d/1cewMfusmPjYWbrnuJRuKhPMwRe_b9PaT/view</a>)</p>
  
  <pre><code>import time
  from absl import app, flags, logging
  from absl.flags import FLAGS
  import core.utils as utils
  from core.yolov4 import YOLOv4, YOLOv3, YOLOv3_tiny, decode
  from PIL import Image
  from core.config import cfg
  import cv2
  import numpy as np
  import tensorflow as tf
  
  flags.DEFINE_string('framework', 'tf', '(tf, tflite')
  flags.DEFINE_string('weights', './data/yolov4.weights',
                      'path to weights file')
  flags.DEFINE_integer('size', 608, 'resize images to')
  flags.DEFINE_boolean('tiny', False, 'yolo or yolo-tiny')
  flags.DEFINE_string('model', 'yolov4', 'yolov3 or yolov4')
  flags.DEFINE_string('image', './data/kite.jpg', 'path to input image')
  flags.DEFINE_string('output', 'result.png', 'path to output image')
  
  def main(_argv):
      if FLAGS.tiny:
          STRIDES = np.array(cfg.YOLO.STRIDES_TINY)
          ANCHORS = utils.get_anchors(cfg.YOLO.ANCHORS_TINY, FLAGS.tiny)
      else:
          STRIDES = np.array(cfg.YOLO.STRIDES)
          if FLAGS.model == 'yolov4':
              ANCHORS = utils.get_anchors(cfg.YOLO.ANCHORS, FLAGS.tiny)
          else:
              ANCHORS = utils.get_anchors(cfg.YOLO.ANCHORS_V3, FLAGS.tiny)
      NUM_CLASS = len(utils.read_class_names(cfg.YOLO.CLASSES))
      XYSCALE = cfg.YOLO.XYSCALE
      input_size = FLAGS.size
      image_path = FLAGS.image
  
      original_image = cv2.imread(image_path)
      original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
      original_image_size = original_image.shape[:2]
  
      image_data = utils.image_preprocess(np.copy(original_image), [input_size, input_size])
      image_data = image_data[np.newaxis, ...].astype(np.float32)
      if FLAGS.framework == 'tf':
          input_layer = tf.keras.layers.Input([input_size, input_size, 3])
          if FLAGS.tiny:
              feature_maps = YOLOv3_tiny(input_layer, NUM_CLASS)
              bbox_tensors = []
              for i, fm in enumerate(feature_maps):
                  bbox_tensor = decode(fm, NUM_CLASS, i)
                  bbox_tensors.append(bbox_tensor)
              model = tf.keras.Model(input_layer, bbox_tensors)
              utils.load_weights_tiny(model, FLAGS.weights)
          else:
              if FLAGS.model == 'yolov3':
                  feature_maps = YOLOv3(input_layer, NUM_CLASS)
                  bbox_tensors = []
                  for i, fm in enumerate(feature_maps):
                      bbox_tensor = decode(fm, NUM_CLASS, i)
                      bbox_tensors.append(bbox_tensor)
                  model = tf.keras.Model(input_layer, bbox_tensors)
                  utils.load_weights_v3(model, FLAGS.weights)
              elif FLAGS.model == 'yolov4':
                  feature_maps = YOLOv4(input_layer, NUM_CLASS)
                  bbox_tensors = []
                  for i, fm in enumerate(feature_maps):
                      bbox_tensor = decode(fm, NUM_CLASS, i)
                      bbox_tensors.append(bbox_tensor)
                  model = tf.keras.Model(input_layer, bbox_tensors)
  
                  if FLAGS.weights.split(".")[len(FLAGS.weights.split(".")) - 1] == "weights":
                      utils.load_weights(model, FLAGS.weights)
                  else:
                      model.load_weights(FLAGS.weights).expect_partial()
  
          model.summary()
          pred_bbox = model.predict(image_data)
      else:
          # Load TFLite model and allocate tensors.
          interpreter = tf.lite.Interpreter(model_path=FLAGS.weights)
          interpreter.allocate_tensors()
          # Get input and output tensors.
          input_details = interpreter.get_input_details()
          output_details = interpreter.get_output_details()
          print(input_details)
          print(output_details)
          interpreter.set_tensor(input_details[0]['index'], image_data)
          interpreter.invoke()
          pred_bbox = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))]
  
      if FLAGS.model == 'yolov4':
          pred_bbox = utils.postprocess_bbbox(pred_bbox, ANCHORS, STRIDES, XYSCALE)
      else:
          pred_bbox = utils.postprocess_bbbox(pred_bbox, ANCHORS, STRIDES)
      bboxes = utils.postprocess_boxes(pred_bbox, original_image_size, input_size, 0.25)
      bboxes = utils.nms(bboxes, 0.213, method='nms')
  
      image = utils.draw_bbox(original_image, bboxes)
      image = Image.fromarray(image)
      image.show()
      # image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)
      # cv2.imwrite(FLAGS.output, image)
  
  if __name__ == '__main__':
      try:
          app.run(main)
      except SystemExit:
          pass
  </code></pre>
  
  <p>Error log:</p>
  
  <pre><code>Traceback (most recent call last):
    File "detect.py", line 100, in &lt;module&gt;
      app.run(main)
    File "/usr/local/lib/python3.6/dist-packages/absl/app.py", line 299, in run
      _run_main(main, args)
    File "/usr/local/lib/python3.6/dist-packages/absl/app.py", line 250, in _run_main
      sys.exit(main(argv))
    File "detect.py", line 68, in main
      utils.load_weights(model, FLAGS.weights)
    File "/content/tensorflow-yolov4/core/utils.py", line 114, in load_weights
      conv_weights = conv_weights.reshape(conv_shape).transpose([2, 3, 1, 0])
  ValueError: cannot reshape array of size 1665179 into shape (512,512,3,3)
  </code></pre>
  
  <p>You can reproduce this error with github : <a href="https://github.com/hunglc007/tensorflow-yolov4-tflite/blob/master/detect.py" rel="nofollow noreferrer">https://github.com/hunglc007/tensorflow-yolov4-tflite/blob/master/detect.py</a> and trying to do demo detection with the pre-trained weight </p>