Answers.Body: <p>That depends! You can try it. <strong>But if you change the sizes, you have to ensure that you do not mismatch the shapes.</strong> As far as size is concerned it won't affect the accuracy much unless you are significantly changing it.</p>
  <p>Since the default is 1024x1024, and you are making 1100x1100, there wont be any issues.</p>
  <p>Remember, there is a tradeoff in terms of speed and the amount of information you can derive from the image. The larger the image size, the higher the computation time and the image information you have.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-11-06T15:20:50.313Z
Answers.Text: Thank you! This makes very good sense, and is very helpful!
Answers.UserDisplayName: sneeze_shiny
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-11-06T05:41:03.077Z
Answers.LastActivityDate: 2020-11-06T05:41:03.077Z
Answers.UserDisplayName: Aniket Velhankar
Body: <p>I am training a convolutional neural network to detect objects (weeds amongst crops, in my case) using TensorFlow. The original dimensions of the raw training photos are 4000 x 3000 pixels, which must be resized to become workable. The idea here is to label objects in the training images (using Label-Img), train the model, and use it to detect weeds in certain situations.</p>
  <p>According to <a href="https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md" rel="nofollow noreferrer">TensorFlow 2 Detection Model Zoo</a>, there are algorithms designed for different speeds, which involves initially resizing the images to a specified dimension. Although this is not a coding question, here is an example of SSD ResNet-50, which initially resizes the input images to 1024 x 1024 pixels:</p>
  <pre><code>model {
    ssd {
      num_classes: 1
      image_resizer {
        fixed_shape_resizer {
          height: 1024
          width: 1024
        }
      }
      feature_extractor {
        type: &quot;ssd_resnet50_v1_fpn_keras&quot;
        depth_multiplier: 1.0
        min_depth: 16
        conv_hyperparams {
          regularizer {
            l2_regularizer {
              weight: 0.00039999998989515007
            }
          }
          initializer {
            truncated_normal_initializer {
              mean: 0.0
              stddev: 0.029999999329447746
            }
          }
          activation: RELU_6
          batch_norm {
            decay: 0.996999979019165
            scale: true
            epsilon: 0.0010000000474974513
          }
        }
        override_base_feature_extractor_hyperparams: true
        fpn {
          min_level: 3
          max_level: 7
        }
      }
      box_coder {
        faster_rcnn_box_coder {
          y_scale: 10.0
          x_scale: 10.0
          height_scale: 5.0
          width_scale: 5.0
        }
      }
      matcher {
        argmax_matcher {
          matched_threshold: 0.5
          unmatched_threshold: 0.5
          ignore_thresholds: false
          negatives_lower_than_unmatched: true
          force_match_for_each_row: true
          use_matmul_gather: true
        }
      }
      similarity_calculator {
        iou_similarity {
        }
      }
      box_predictor {
        weight_shared_convolutional_box_predictor {
          conv_hyperparams {
            regularizer {
              l2_regularizer {
                weight: 0.00039999998989515007
              }
            }
            initializer {
              random_normal_initializer {
                mean: 0.0
                stddev: 0.009999999776482582
              }
            }
            activation: RELU_6
            batch_norm {
              decay: 0.996999979019165
              scale: true
              epsilon: 0.0010000000474974513
            }
          }
          depth: 256
          num_layers_before_predictor: 4
          kernel_size: 3
          class_prediction_bias_init: -4.599999904632568
        }
      }
      anchor_generator {
        multiscale_anchor_generator {
          min_level: 3
          max_level: 7
          anchor_scale: 4.0
          aspect_ratios: 1.0
          aspect_ratios: 2.0
          aspect_ratios: 0.5
          scales_per_octave: 2
        }
      }
      post_processing {
        batch_non_max_suppression {
          score_threshold: 9.99999993922529e-09
          iou_threshold: 0.6000000238418579
          max_detections_per_class: 100
          max_total_detections: 100
          use_static_shapes: false
        }
        score_converter: SIGMOID
      }
      normalize_loss_by_num_matches: true
      loss {
        localization_loss {
          weighted_smooth_l1 {
          }
        }
        classification_loss {
          weighted_sigmoid_focal {
            gamma: 2.0
            alpha: 0.25
          }
        }
        classification_weight: 1.0
        localization_weight: 1.0
      }
      encode_background_as_zeros: true
      normalize_loc_loss_by_codesize: true
      inplace_batchnorm_update: true
      freeze_batchnorm: false
    }
  }
  train_config {
    batch_size: 64
    data_augmentation_options {
      random_horizontal_flip {
      }
    }
    data_augmentation_options {
      random_crop_image {
        min_object_covered: 0.0
        min_aspect_ratio: 0.75
        max_aspect_ratio: 3.0
        min_area: 0.75
        max_area: 1.0
        overlap_thresh: 0.0
      }
    }
    sync_replicas: true
    optimizer {
      momentum_optimizer {
        learning_rate {
          cosine_decay_learning_rate {
            learning_rate_base: 0.03999999910593033
            total_steps: 100000
            warmup_learning_rate: 0.013333000242710114
            warmup_steps: 2000
          }
        }
        momentum_optimizer_value: 0.8999999761581421
      }
      use_moving_average: false
    }
    fine_tune_checkpoint: &quot;PATH_TO_BE_CONFIGURED&quot;
    num_steps: 100000
    startup_delay_steps: 0.0
    replicas_to_aggregate: 8
    max_number_of_boxes: 100
    unpad_groundtruth_tensors: false
    fine_tune_checkpoint_type: &quot;classification&quot;
    use_bfloat16: true
    fine_tune_checkpoint_version: V2
  }
  train_input_reader {
    label_map_path: &quot;PATH_TO_BE_CONFIGURED&quot;
    tf_record_input_reader {
      input_path: &quot;PATH_TO_BE_CONFIGURED&quot;
    }
  }
  eval_config {
    metrics_set: &quot;coco_detection_metrics&quot;
    use_moving_averages: false
  }
  eval_input_reader {
    label_map_path: &quot;PATH_TO_BE_CONFIGURED&quot;
    shuffle: false
    num_epochs: 1
    tf_record_input_reader {
      input_path: &quot;PATH_TO_BE_CONFIGURED&quot;
    }
  }
  </code></pre>
  <p>Because I will be labeling many pictures in the future, I need to decide on a dimension to resize my original ones to (literature review says 1100 x 1100 has been used in previous projects).</p>
  <p><strong>If I were to change the image resizer in the code above to 1100 x 1100, for example, would that have any effect on model accuracy/training loss?</strong> Would it even run? I'm fairly new to this, so any insights on this would be greatly appreciated!</p>
  <p>Note: I am using a NVIDIA GPU, so that helps speed the process quite a bit. Google Colab also can be used.</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-11-06T12:13:46.457Z
Comments.Text: I didn't read this post, so I don't really know what your problem/question is. However, I would like to note that programming issues are generally off-topic here. We focus on conceptual/theoretical questions/topics related to AI. Take a look at https://ai.stackexchange.com/help/on-topic.
Comments.UserDisplayName: nbro
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-11-06T15:21:48.487Z
Comments.Text: Thank you for the information. I just provided the code as an example, as indicated in the second paragraph. Just to illustrate my question a bit better.
Comments.UserDisplayName: sneeze_shiny
Tags: <neural-networks><convolutional-neural-networks><training><object-detection>
Title: Will changing the dimension reduction size of a neural network (i.e. SSD ResNet-50) change the overall outcome and accuracy of the model?
UserDisplayName: sneeze_shiny
ThreadText: # Will changing the dimension reduction size of a neural network (i.e. SSD ResNet-50) change the overall outcome and accuracy of the model?
  
  (Asked by: username_0 on 2020-11-06)
  
  I am training a convolutional neural network to detect objects (weeds amongst crops, in my case) using TensorFlow. The original dimensions of the raw training photos are 4000 x 3000 pixels, which must be resized to become workable. The idea here is to label objects in the training images (using Label-Img), train the model, and use it to detect weeds in certain situations.
  According to TensorFlow 2 Detection Model Zoo, there are algorithms designed for different speeds, which involves initially resizing the images to a specified dimension. Although this is not a coding question, here is an example of SSD ResNet-50, which initially resizes the input images to 1024 x 1024 pixels:
  model {
    ssd {
      num_classes: 1
      image_resizer {
        fixed_shape_resizer {
          height: 1024
          width: 1024
        }
      }
      feature_extractor {
        type: "ssd_resnet50_v1_fpn_keras"
        depth_multiplier: 1.0
        min_depth: 16
        conv_hyperparams {
          regularizer {
            l2_regularizer {
              weight: 0.00039999998989515007
            }
          }
          initializer {
            truncated_normal_initializer {
              mean: 0.0
              stddev: 0.029999999329447746
            }
          }
          activation: RELU_6
          batch_norm {
            decay: 0.996999979019165
            scale: true
            epsilon: 0.0010000000474974513
          }
        }
        override_base_feature_extractor_hyperparams: true
        fpn {
          min_level: 3
          max_level: 7
        }
      }
      box_coder {
        faster_rcnn_box_coder {
          y_scale: 10.0
          x_scale: 10.0
          height_scale: 5.0
          width_scale: 5.0
        }
      }
      matcher {
        argmax_matcher {
          matched_threshold: 0.5
          unmatched_threshold: 0.5
          ignore_thresholds: false
          negatives_lower_than_unmatched: true
          force_match_for_each_row: true
          use_matmul_gather: true
        }
      }
      similarity_calculator {
        iou_similarity {
        }
      }
      box_predictor {
        weight_shared_convolutional_box_predictor {
          conv_hyperparams {
            regularizer {
              l2_regularizer {
                weight: 0.00039999998989515007
              }
            }
            initializer {
              random_normal_initializer {
                mean: 0.0
                stddev: 0.009999999776482582
              }
            }
            activation: RELU_6
            batch_norm {
              decay: 0.996999979019165
              scale: true
              epsilon: 0.0010000000474974513
            }
          }
          depth: 256
          num_layers_before_predictor: 4
          kernel_size: 3
          class_prediction_bias_init: -4.599999904632568
        }
      }
      anchor_generator {
        multiscale_anchor_generator {
          min_level: 3
          max_level: 7
          anchor_scale: 4.0
          aspect_ratios: 1.0
          aspect_ratios: 2.0
          aspect_ratios: 0.5
          scales_per_octave: 2
        }
      }
      post_processing {
        batch_non_max_suppression {
          score_threshold: 9.99999993922529e-09
          iou_threshold: 0.6000000238418579
          max_detections_per_class: 100
          max_total_detections: 100
          use_static_shapes: false
        }
        score_converter: SIGMOID
      }
      normalize_loss_by_num_matches: true
      loss {
        localization_loss {
          weighted_smooth_l1 {
          }
        }
        classification_loss {
          weighted_sigmoid_focal {
            gamma: 2.0
            alpha: 0.25
          }
        }
        classification_weight: 1.0
        localization_weight: 1.0
      }
      encode_background_as_zeros: true
      normalize_loc_loss_by_codesize: true
      inplace_batchnorm_update: true
      freeze_batchnorm: false
    }
  }
  train_config {
    batch_size: 64
    data_augmentation_options {
      random_horizontal_flip {
      }
    }
    data_augmentation_options {
      random_crop_image {
        min_object_covered: 0.0
        min_aspect_ratio: 0.75
        max_aspect_ratio: 3.0
        min_area: 0.75
        max_area: 1.0
        overlap_thresh: 0.0
      }
    }
    sync_replicas: true
    optimizer {
      momentum_optimizer {
        learning_rate {
          cosine_decay_learning_rate {
            learning_rate_base: 0.03999999910593033
            total_steps: 100000
            warmup_learning_rate: 0.013333000242710114
            warmup_steps: 2000
          }
        }
        momentum_optimizer_value: 0.8999999761581421
      }
      use_moving_average: false
    }
    fine_tune_checkpoint: "PATH_TO_BE_CONFIGURED"
    num_steps: 100000
    startup_delay_steps: 0.0
    replicas_to_aggregate: 8
    max_number_of_boxes: 100
    unpad_groundtruth_tensors: false
    fine_tune_checkpoint_type: "classification"
    use_bfloat16: true
    fine_tune_checkpoint_version: V2
  }
  train_input_reader {
    label_map_path: "PATH_TO_BE_CONFIGURED"
    tf_record_input_reader {
      input_path: "PATH_TO_BE_CONFIGURED"
    }
  }
  eval_config {
    metrics_set: "coco_detection_metrics"
    use_moving_averages: false
  }
  eval_input_reader {
    label_map_path: "PATH_TO_BE_CONFIGURED"
    shuffle: false
    num_epochs: 1
    tf_record_input_reader {
      input_path: "PATH_TO_BE_CONFIGURED"
    }
  }
  
  Because I will be labeling many pictures in the future, I need to decide on a dimension to resize my original ones to (literature review says 1100 x 1100 has been used in previous projects).
  If I were to change the image resizer in the code above to 1100 x 1100, for example, would that have any effect on model accuracy/training loss? Would it even run? I'm fairly new to this, so any insights on this would be greatly appreciated!
  Note: I am using a NVIDIA GPU, so that helps speed the process quite a bit. Google Colab also can be used.
  
  **Tags:** neural-networks, convolutional-neural-networks, training, object-detection
  > **Comments:**
  > **username_1**: I didn't read this post, so I don't really know what your problem/question is. However, I would like to note that programming issues are generally off-topic here. We focus on conceptual/theoretical questions/topics related to AI. Take a look at https://ai.stackexchange.com/help/on-topic.  
  > **username_0**: Thank you for the information. I just provided the code as an example, as indicated in the second paragraph. Just to illustrate my question a bit better.  
  
  ---
  
  ## 1 answers
  
  ### Answer by username_2 on 2020-11-06. Score: 1 | Accepted answer
  
  That depends! You can try it. **But if you change the sizes, you have to ensure that you do not mismatch the shapes.** As far as size is concerned it won't affect the accuracy much unless you are significantly changing it.
  
  Since the default is 1024x1024, and you are making 1100x1100, there wont be any issues.
  
  Remember, there is a tradeoff in terms of speed and the amount of information you can derive from the image. The larger the image size, the higher the computation time and the image information you have.
  
  > **Comments:**
  > **username_0**: Thank you! This makes very good sense, and is very helpful!  
  
  ---
  
  