diff --git a/Computer Vision/Plant_Disease_Detection_System/README.md b/Computer Vision/Plant_Disease_Detection_System/README.md
new file mode 100644
index 00000000..6c504daf
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/README.md
@@ -0,0 +1,116 @@
+# Plant-disease-detection
+
+## About the Project
+An application that for farmers to detect the type of plant or crops, detect any kind of diseases in them. The app sends the image of the plant to the server where it is analysed using CNN classifier model. Once detected, the disease and its solutions are displayed to the user
+
+## Model
+
+Trained to identify 5 classes for **Disease Detection** and 24 classes for **Disease Classification**.
+Dataset can be downloaded form [kaggle](https://www.kaggle.com/abdallahalidev/plantvillage-dataset)
+
+ - Disease Classification Classes
+
+ - Apple___Apple_scab
+ - Apple___Black_rot
+ - Apple___Cedar_apple_rust
+ - Apple___healthy
+ - Blueberry___healthy
+ - Cherry___healthy
+ - Cherry___Powdery_mildew
+ - Grape___Black_rot
+ - Grape___Esca_Black_Measles
+ - Grape___healthy
+ - Grape___Leaf_blight_Isariopsis_Leaf_Spot
+ - Orange___Haunglongbing
+ - Peach___Bacterial_spot
+ - Peach___healthy
+ - Pepper,_bell___Bacterial_spot
+ - Pepper,_bell___healthy
+ - Potato___Early_blight
+ - Potato___healthy
+ - Raspberry___healthy
+ - Soybean___healthy
+ - Squash___Powdery_mildew
+ - Strawberry___healthy
+ - Strawberry___Leaf_scorch
+
+ - Disease Detection Classes
+
+ - Cherry___healthy
+ - Cherry___Powdery_mildew
+ - Grape___Black_rot
+ - Grape___Esca_Black_Measles
+ - Grape___healthy
+ - Grape___Leaf_blight_Isariopsis_Leaf_Spot
+---
+## Cloning the project
+* Run command `git clone "https://github.com/Saideepthi123/Plant-disease-detection.git"` and change into the project folder
+* Create a virtual environment `env` in the repository (use virtualenv, etc)
+* Activate virtual environment
+* Install the requirements
+
+
+To create virtual environment and install requirements run following commands
+```shell script
+virtualenv env
+```
+
+To activate the environment use following commands:
+Window:
+```shell script
+.\env\Scripts\activate
+```
+Ubuntu/Linux
+```shell script
+source env/bin/activate
+```
+pip install -r requirements.txt
+
+Command to run the app
+---
+ - streamlit run app.py
+
+## Demo
+
+- About
+
+ 
+
+- Disease Predection
+
+ 
+
+ - Image Upload
+
+ 
+
+ - Image Detected
+
+
+ 
+
+
+- Disease Classification
+
+ - Image Upload
+
+ 
+
+ - Image Classified
+
+ 
+
+- Treatement Page
+
+ 
+
+## Required Libraries
+- opencv-contrib-python-headless
+- tensorflow-cpu
+- streamlit
+- numpy
+- pandas
+- pillow
+- keras
+- matplotlib
+
diff --git a/Computer Vision/Plant_Disease_Detection_System/app.py b/Computer Vision/Plant_Disease_Detection_System/app.py
new file mode 100644
index 00000000..83b25616
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/app.py
@@ -0,0 +1,185 @@
+import os
+import time
+import cv2
+import sys
+import csv
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+import tensorflow as tf
+import keras_preprocessing
+import streamlit as st
+import numpy as np
+import pandas as pd
+from numpy import argmax
+from PIL import Image, ImageEnhance
+from resizeimage import resizeimage
+from utils import label_map_util
+from utils import visualization_utils as vis_util
+from keras_preprocessing import image
+from keras_preprocessing.image import ImageDataGenerator
+from pathlib import Path
+
+# Ensure compatibility with TensorFlow 2.x
+tf.executing_eagerly()
+
+MODEL_NAME = './object_detection/inference_graph'
+IMAGE_NAME = './object_detection/images/out.jpg'
+
+CWD_PATH = os.getcwd()
+
+PATH_TO_CKPT = os.path.join('./object_detection/inference_graph/frozen_inference_graph.pb')
+PATH_TO_LABELS = os.path.join('./object_detection/training/labelmap.pbtxt')
+PATH_TO_IMAGE = os.path.join('./object_detection/images/out.jpg')
+
+NUM_CLASSES = 6
+
+# Load label map
+label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
+categories = label_map_util.convert_label_map_to_categories(
+ label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
+category_index = label_map_util.create_category_index(categories)
+
+# Load frozen TensorFlow model into memory
+detection_graph = tf.compat.v1.Graph()
+with detection_graph.as_default():
+ od_graph_def = tf.compat.v1.GraphDef()
+ with tf.io.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
+ serialized_graph = fid.read()
+ od_graph_def.ParseFromString(serialized_graph)
+ tf.import_graph_def(od_graph_def, name='')
+
+ sess = tf.compat.v1.Session(graph=detection_graph)
+
+# Input tensor is the image
+image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
+
+# Output tensors are the detection boxes, scores, and classes
+detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
+detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
+detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
+
+# Number of objects detected
+num_detections = detection_graph.get_tensor_by_name('num_detections:0')
+
+# Load image using OpenCV
+in_image = cv2.imread(PATH_TO_IMAGE)
+image_rgb = cv2.cvtColor(in_image, cv2.COLOR_BGR2RGB)
+image_expanded = np.expand_dims(image_rgb, axis=0)
+
+# Perform the actual detection by running the model
+(boxes, scores, classes, num) = sess.run(
+ [detection_boxes, detection_scores, detection_classes, num_detections],
+ feed_dict={image_tensor: image_expanded})
+
+# Draw the results of the detection
+# Updated fix for FreeTypeFont issue using getbbox()
+vis_util.visualize_boxes_and_labels_on_image_array(
+ in_image,
+ np.squeeze(boxes),
+ np.squeeze(classes).astype(np.int32),
+ np.squeeze(scores),
+ category_index,
+ use_normalized_coordinates=True,
+ line_thickness=8,
+ min_score_thresh=0.60)
+
+# Update getsize() to getbbox() inside visualization_utils.py:
+# Replace this line:
+# display_str_heights = [font.getsize(ds)[1] for ds in display_str_list]
+# With this:
+# display_str_heights = [font.getbbox(ds)[3] - font.getbbox(ds)[1] for ds in display_str_list]
+
+
+# Streamlit UI components
+def read_markdown_file(markdown_file):
+ return Path(markdown_file).read_text()
+
+def classification():
+ global path
+ global cn
+ model = tf.keras.models.Sequential([
+ tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(150, 150, 3)),
+ tf.keras.layers.MaxPooling2D(2, 2),
+ tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
+ tf.keras.layers.MaxPooling2D(2, 2),
+ tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),
+ tf.keras.layers.MaxPooling2D(2, 2),
+ tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),
+ tf.keras.layers.MaxPooling2D(2, 2),
+ tf.keras.layers.Flatten(),
+ tf.keras.layers.Dropout(0.5),
+ tf.keras.layers.Dense(512, activation='relu'),
+ tf.keras.layers.Dense(24, activation='softmax')
+ ])
+
+ LABELS = [
+ 'Apple___Apple_scab', 'Apple___Black_rot', 'Apple___Cedar_apple_rust', 'Apple___healthy',
+ 'Blueberry___healthy', 'Cherry___healthy', 'Cherry___Powdery_mildew', 'Grape___Black_rot',
+ 'Grape___Esca_Black_Measles', 'Grape___healthy', 'Grape___Leaf_blight_Isariopsis_Leaf_Spot',
+ 'Orange___Haunglongbing', 'Peach___Bacterial_spot', 'Peach___healthy',
+ 'Pepper_bell___Bacterial_spot', 'Pepper_bell___healthy', 'Potato___Early_blight',
+ 'Potato___healthy', 'Potato___Late_blight', 'Raspberry___healthy', 'Soybean___healthy',
+ 'Squash___Powdery_mildew', 'Strawberry___healthy', 'Strawberry___Leaf_scorch'
+ ]
+
+ model.load_weights("./object_classification/rps.h5")
+ path = './object_classification/images/out.jpg'
+ img = image.load_img(path, target_size=(150, 150))
+ x = image.img_to_array(img)
+ x = np.expand_dims(x, axis=0)
+ images = np.vstack([x])
+ classes = model.predict(images, batch_size=10)
+ result = argmax(classes)
+ cn = LABELS[result]
+
+classification()
+
+# Main Streamlit app function
+def main():
+ st.markdown('', unsafe_allow_html=True)
+ st.title("Plant Disease Detection & Classification")
+ st.text("Built with Streamlit and TensorFlow")
+
+ activities = ["About", "Plant Disease"]
+ choice = st.sidebar.selectbox("Select Activity", activities)
+ enhance_type = st.sidebar.radio("Type", ["Detection", "Classification", "Treatment"])
+
+ if choice == 'About':
+ intro_markdown = read_markdown_file("./doc/about.md")
+ st.markdown(intro_markdown, unsafe_allow_html=True)
+
+ if choice == 'Plant Disease' and enhance_type == 'Detection':
+ st.header("Plant Disease Detection")
+ image_file = st.file_uploader("Upload Image", type=['jpg'])
+ st.markdown("* * *")
+
+ if image_file is not None:
+ our_image = Image.open(image_file)
+ our_image.save('./object_detection/images/out.jpg')
+
+ if st.button('Process'):
+ st.image(in_image, use_column_width=True, channels='RGB')
+ st.image(our_image, use_column_width=True, channels='RGB')
+ st.balloons()
+
+ if choice == 'Plant Disease' and enhance_type == 'Classification':
+ st.header("Plant Disease Classification")
+ image_input = st.file_uploader("Upload Image", type=['jpg'])
+ st.markdown("* * *")
+
+ if image_input is not None:
+ some_image = Image.open(image_input)
+ some_image.save('./object_classification/images/out.jpg')
+
+ if st.button('Classify'):
+ st.image(path, use_column_width=True)
+ with st.spinner('Your image is processing'):
+ time.sleep(5)
+ st.success(cn)
+ st.balloons()
+
+ if enhance_type == 'Treatment' and choice == 'Plant Disease':
+ data_markdown = read_markdown_file("./treatment/treatment.md")
+ st.markdown(data_markdown, unsafe_allow_html=True)
+
+main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/__init__.py b/Computer Vision/Plant_Disease_Detection_System/core/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/__init__.cpython-312.pyc b/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..bf26542c
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/__init__.cpython-312.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/standard_fields.cpython-312.pyc b/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/standard_fields.cpython-312.pyc
new file mode 100644
index 00000000..41d494b7
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/core/__pycache__/standard_fields.cpython-312.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/anchor_generator.py b/Computer Vision/Plant_Disease_Detection_System/core/anchor_generator.py
new file mode 100644
index 00000000..070b1d68
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/anchor_generator.py
@@ -0,0 +1,171 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base anchor generator.
+
+The job of the anchor generator is to create (or load) a collection
+of bounding boxes to be used as anchors.
+
+Generated anchors are assumed to match some convolutional grid or list of grid
+shapes. For example, we might want to generate anchors matching an 8x8
+feature map and a 4x4 feature map. If we place 3 anchors per grid location
+on the first feature map and 6 anchors per grid location on the second feature
+map, then 3*8*8 + 6*4*4 = 288 anchors are generated in total.
+
+To support fully convolutional settings, feature map shapes are passed
+dynamically at generation time. The number of anchors to place at each location
+is static --- implementations of AnchorGenerator must always be able return
+the number of anchors that it uses per location for each feature map.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+from six.moves import zip
+import tensorflow as tf
+
+
+class AnchorGenerator(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for anchor generators."""
+
+ @abstractmethod
+ def name_scope(self):
+ """Name scope.
+
+ Must be defined by implementations.
+
+ Returns:
+ a string representing the name scope of the anchor generation operation.
+ """
+ pass
+
+ @property
+ def check_num_anchors(self):
+ """Whether to dynamically check the number of anchors generated.
+
+ Can be overridden by implementations that would like to disable this
+ behavior.
+
+ Returns:
+ a boolean controlling whether the Generate function should dynamically
+ check the number of anchors generated against the mathematically
+ expected number of anchors.
+ """
+ return True
+
+ @abstractmethod
+ def num_anchors_per_location(self):
+ """Returns the number of anchors per spatial location.
+
+ Returns:
+ a list of integers, one for each expected feature map to be passed to
+ the `generate` function.
+ """
+ pass
+
+ def generate(self, feature_map_shape_list, **params):
+ """Generates a collection of bounding boxes to be used as anchors.
+
+ TODO(rathodv): remove **params from argument list and make stride and
+ offsets (for multiple_grid_anchor_generator) constructor arguments.
+
+ Args:
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with. Pairs can be provided as 1-dimensional
+ integer tensors of length 2 or simply as tuples of integers.
+ **params: parameters for anchor generation op
+
+ Returns:
+ boxes_list: a list of BoxLists each holding anchor boxes corresponding to
+ the input feature map shapes.
+
+ Raises:
+ ValueError: if the number of feature map shapes does not match the length
+ of NumAnchorsPerLocation.
+ """
+ if self.check_num_anchors and (
+ len(feature_map_shape_list) != len(self.num_anchors_per_location())):
+ raise ValueError('Number of feature maps is expected to equal the length '
+ 'of `num_anchors_per_location`.')
+ with tf.name_scope(self.name_scope()):
+ anchors_list = self._generate(feature_map_shape_list, **params)
+ if self.check_num_anchors:
+ with tf.control_dependencies([
+ self._assert_correct_number_of_anchors(
+ anchors_list, feature_map_shape_list)]):
+ for item in anchors_list:
+ item.set(tf.identity(item.get()))
+ return anchors_list
+
+ @abstractmethod
+ def _generate(self, feature_map_shape_list, **params):
+ """To be overridden by implementations.
+
+ Args:
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with.
+ **params: parameters for anchor generation op
+
+ Returns:
+ boxes_list: a list of BoxList, each holding a collection of N anchor
+ boxes.
+ """
+ pass
+
+ def anchor_index_to_feature_map_index(self, boxlist_list):
+ """Returns a 1-D array of feature map indices for each anchor.
+
+ Args:
+ boxlist_list: a list of Boxlist, each holding a collection of N anchor
+ boxes. This list is produced in self.generate().
+
+ Returns:
+ A [num_anchors] integer array, where each element indicates which feature
+ map index the anchor belongs to.
+ """
+ feature_map_indices_list = []
+ for i, boxes in enumerate(boxlist_list):
+ feature_map_indices_list.append(
+ i * tf.ones([boxes.num_boxes()], dtype=tf.int32))
+ return tf.concat(feature_map_indices_list, axis=0)
+
+ def _assert_correct_number_of_anchors(self, anchors_list,
+ feature_map_shape_list):
+ """Assert that correct number of anchors was generated.
+
+ Args:
+ anchors_list: A list of box_list.BoxList object holding anchors generated.
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with.
+ Returns:
+ Op that raises InvalidArgumentError if the number of anchors does not
+ match the number of expected anchors.
+ """
+ expected_num_anchors = 0
+ actual_num_anchors = 0
+ for num_anchors_per_location, feature_map_shape, anchors in zip(
+ self.num_anchors_per_location(), feature_map_shape_list, anchors_list):
+ expected_num_anchors += (num_anchors_per_location
+ * feature_map_shape[0]
+ * feature_map_shape[1])
+ actual_num_anchors += anchors.num_boxes()
+ return tf.assert_equal(expected_num_anchors, actual_num_anchors)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler.py b/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler.py
new file mode 100644
index 00000000..89c1fc7f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler.py
@@ -0,0 +1,266 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Class to subsample minibatches by balancing positives and negatives.
+
+Subsamples minibatches based on a pre-specified positive fraction in range
+[0,1]. The class presumes there are many more negatives than positive examples:
+if the desired batch_size cannot be achieved with the pre-specified positive
+fraction, it fills the rest with negative examples. If this is not sufficient
+for obtaining the desired batch_size, it returns fewer examples.
+
+The main function to call is Subsample(self, indicator, labels). For convenience
+one can also call SubsampleWeights(self, weights, labels) which is defined in
+the minibatch_sampler base class.
+
+When is_static is True, it implements a method that guarantees static shapes.
+It also ensures the length of output of the subsample is always batch_size, even
+when number of examples set to True in indicator is less than batch_size.
+"""
+
+import tensorflow as tf
+
+from object_detection.core import minibatch_sampler
+from object_detection.utils import ops
+
+
+class BalancedPositiveNegativeSampler(minibatch_sampler.MinibatchSampler):
+ """Subsamples minibatches to a desired balance of positives and negatives."""
+
+ def __init__(self, positive_fraction=0.5, is_static=False):
+ """Constructs a minibatch sampler.
+
+ Args:
+ positive_fraction: desired fraction of positive examples (scalar in [0,1])
+ in the batch.
+ is_static: If True, uses an implementation with static shape guarantees.
+
+ Raises:
+ ValueError: if positive_fraction < 0, or positive_fraction > 1
+ """
+ if positive_fraction < 0 or positive_fraction > 1:
+ raise ValueError('positive_fraction should be in range [0,1]. '
+ 'Received: %s.' % positive_fraction)
+ self._positive_fraction = positive_fraction
+ self._is_static = is_static
+
+ def _get_num_pos_neg_samples(self, sorted_indices_tensor, sample_size):
+ """Counts the number of positives and negatives numbers to be sampled.
+
+ Args:
+ sorted_indices_tensor: A sorted int32 tensor of shape [N] which contains
+ the signed indices of the examples where the sign is based on the label
+ value. The examples that cannot be sampled are set to 0. It samples
+ atmost sample_size*positive_fraction positive examples and remaining
+ from negative examples.
+ sample_size: Size of subsamples.
+
+ Returns:
+ A tuple containing the number of positive and negative labels in the
+ subsample.
+ """
+ input_length = tf.shape(sorted_indices_tensor)[0]
+ valid_positive_index = tf.greater(sorted_indices_tensor,
+ tf.zeros(input_length, tf.int32))
+ num_sampled_pos = tf.reduce_sum(tf.cast(valid_positive_index, tf.int32))
+ max_num_positive_samples = tf.constant(
+ int(sample_size * self._positive_fraction), tf.int32)
+ num_positive_samples = tf.minimum(max_num_positive_samples, num_sampled_pos)
+ num_negative_samples = tf.constant(sample_size,
+ tf.int32) - num_positive_samples
+
+ return num_positive_samples, num_negative_samples
+
+ def _get_values_from_start_and_end(self, input_tensor, num_start_samples,
+ num_end_samples, total_num_samples):
+ """slices num_start_samples and last num_end_samples from input_tensor.
+
+ Args:
+ input_tensor: An int32 tensor of shape [N] to be sliced.
+ num_start_samples: Number of examples to be sliced from the beginning
+ of the input tensor.
+ num_end_samples: Number of examples to be sliced from the end of the
+ input tensor.
+ total_num_samples: Sum of is num_start_samples and num_end_samples. This
+ should be a scalar.
+
+ Returns:
+ A tensor containing the first num_start_samples and last num_end_samples
+ from input_tensor.
+
+ """
+ input_length = tf.shape(input_tensor)[0]
+ start_positions = tf.less(tf.range(input_length), num_start_samples)
+ end_positions = tf.greater_equal(
+ tf.range(input_length), input_length - num_end_samples)
+ selected_positions = tf.logical_or(start_positions, end_positions)
+ selected_positions = tf.cast(selected_positions, tf.float32)
+ indexed_positions = tf.multiply(tf.cumsum(selected_positions),
+ selected_positions)
+ one_hot_selector = tf.one_hot(tf.cast(indexed_positions, tf.int32) - 1,
+ total_num_samples,
+ dtype=tf.float32)
+ return tf.cast(tf.tensordot(tf.cast(input_tensor, tf.float32),
+ one_hot_selector, axes=[0, 0]), tf.int32)
+
+ def _static_subsample(self, indicator, batch_size, labels):
+ """Returns subsampled minibatch.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ N should be a complie time constant.
+ batch_size: desired batch size. This scalar cannot be None.
+ labels: boolean tensor of shape [N] denoting positive(=True) and negative
+ (=False) examples. N should be a complie time constant.
+
+ Returns:
+ sampled_idx_indicator: boolean tensor of shape [N], True for entries which
+ are sampled. It ensures the length of output of the subsample is always
+ batch_size, even when number of examples set to True in indicator is
+ less than batch_size.
+
+ Raises:
+ ValueError: if labels and indicator are not 1D boolean tensors.
+ """
+ # Check if indicator and labels have a static size.
+ if not indicator.shape.is_fully_defined():
+ raise ValueError('indicator must be static in shape when is_static is'
+ 'True')
+ if not labels.shape.is_fully_defined():
+ raise ValueError('labels must be static in shape when is_static is'
+ 'True')
+ if not isinstance(batch_size, int):
+ raise ValueError('batch_size has to be an integer when is_static is'
+ 'True.')
+
+ input_length = tf.shape(indicator)[0]
+
+ # Set the number of examples set True in indicator to be at least
+ # batch_size.
+ num_true_sampled = tf.reduce_sum(tf.cast(indicator, tf.float32))
+ additional_false_sample = tf.less_equal(
+ tf.cumsum(tf.cast(tf.logical_not(indicator), tf.float32)),
+ batch_size - num_true_sampled)
+ indicator = tf.logical_or(indicator, additional_false_sample)
+
+ # Shuffle indicator and label. Need to store the permutation to restore the
+ # order post sampling.
+ permutation = tf.random_shuffle(tf.range(input_length))
+ indicator = ops.matmul_gather_on_zeroth_axis(
+ tf.cast(indicator, tf.float32), permutation)
+ labels = ops.matmul_gather_on_zeroth_axis(
+ tf.cast(labels, tf.float32), permutation)
+
+ # index (starting from 1) when indicator is True, 0 when False
+ indicator_idx = tf.where(
+ tf.cast(indicator, tf.bool), tf.range(1, input_length + 1),
+ tf.zeros(input_length, tf.int32))
+
+ # Replace -1 for negative, +1 for positive labels
+ signed_label = tf.where(
+ tf.cast(labels, tf.bool), tf.ones(input_length, tf.int32),
+ tf.scalar_mul(-1, tf.ones(input_length, tf.int32)))
+ # negative of index for negative label, positive index for positive label,
+ # 0 when indicator is False.
+ signed_indicator_idx = tf.multiply(indicator_idx, signed_label)
+ sorted_signed_indicator_idx = tf.nn.top_k(
+ signed_indicator_idx, input_length, sorted=True).values
+
+ [num_positive_samples,
+ num_negative_samples] = self._get_num_pos_neg_samples(
+ sorted_signed_indicator_idx, batch_size)
+
+ sampled_idx = self._get_values_from_start_and_end(
+ sorted_signed_indicator_idx, num_positive_samples,
+ num_negative_samples, batch_size)
+
+ # Shift the indices to start from 0 and remove any samples that are set as
+ # False.
+ sampled_idx = tf.abs(sampled_idx) - tf.ones(batch_size, tf.int32)
+ sampled_idx = tf.multiply(
+ tf.cast(tf.greater_equal(sampled_idx, tf.constant(0)), tf.int32),
+ sampled_idx)
+
+ sampled_idx_indicator = tf.cast(tf.reduce_sum(
+ tf.one_hot(sampled_idx, depth=input_length),
+ axis=0), tf.bool)
+
+ # project back the order based on stored permutations
+ reprojections = tf.one_hot(permutation, depth=input_length,
+ dtype=tf.float32)
+ return tf.cast(tf.tensordot(
+ tf.cast(sampled_idx_indicator, tf.float32),
+ reprojections, axes=[0, 0]), tf.bool)
+
+ def subsample(self, indicator, batch_size, labels, scope=None):
+ """Returns subsampled minibatch.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ batch_size: desired batch size. If None, keeps all positive samples and
+ randomly selects negative samples so that the positive sample fraction
+ matches self._positive_fraction. It cannot be None is is_static is True.
+ labels: boolean tensor of shape [N] denoting positive(=True) and negative
+ (=False) examples.
+ scope: name scope.
+
+ Returns:
+ sampled_idx_indicator: boolean tensor of shape [N], True for entries which
+ are sampled.
+
+ Raises:
+ ValueError: if labels and indicator are not 1D boolean tensors.
+ """
+ if len(indicator.get_shape().as_list()) != 1:
+ raise ValueError('indicator must be 1 dimensional, got a tensor of '
+ 'shape %s' % indicator.get_shape())
+ if len(labels.get_shape().as_list()) != 1:
+ raise ValueError('labels must be 1 dimensional, got a tensor of '
+ 'shape %s' % labels.get_shape())
+ if labels.dtype != tf.bool:
+ raise ValueError('labels should be of type bool. Received: %s' %
+ labels.dtype)
+ if indicator.dtype != tf.bool:
+ raise ValueError('indicator should be of type bool. Received: %s' %
+ indicator.dtype)
+ with tf.name_scope(scope, 'BalancedPositiveNegativeSampler'):
+ if self._is_static:
+ return self._static_subsample(indicator, batch_size, labels)
+
+ else:
+ # Only sample from indicated samples
+ negative_idx = tf.logical_not(labels)
+ positive_idx = tf.logical_and(labels, indicator)
+ negative_idx = tf.logical_and(negative_idx, indicator)
+
+ # Sample positive and negative samples separately
+ if batch_size is None:
+ max_num_pos = tf.reduce_sum(tf.cast(positive_idx, dtype=tf.int32))
+ else:
+ max_num_pos = int(self._positive_fraction * batch_size)
+ sampled_pos_idx = self.subsample_indicator(positive_idx, max_num_pos)
+ num_sampled_pos = tf.reduce_sum(tf.cast(sampled_pos_idx, tf.int32))
+ if batch_size is None:
+ negative_positive_ratio = (
+ 1 - self._positive_fraction) / self._positive_fraction
+ max_num_neg = tf.cast(
+ negative_positive_ratio *
+ tf.cast(num_sampled_pos, dtype=tf.float32),
+ dtype=tf.int32)
+ else:
+ max_num_neg = batch_size - num_sampled_pos
+ sampled_neg_idx = self.subsample_indicator(negative_idx, max_num_neg)
+
+ return tf.logical_or(sampled_pos_idx, sampled_neg_idx)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler_test.py b/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler_test.py
new file mode 100644
index 00000000..1df28e4c
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/balanced_positive_negative_sampler_test.py
@@ -0,0 +1,204 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.balanced_positive_negative_sampler."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import balanced_positive_negative_sampler
+from object_detection.utils import test_case
+
+
+class BalancedPositiveNegativeSamplerTest(test_case.TestCase):
+
+ def test_subsample_all_examples_dynamic(self):
+ numpy_labels = np.random.permutation(300)
+ indicator = tf.constant(np.ones(300) == 1)
+ numpy_labels = (numpy_labels - 200) > 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 32)
+
+ def test_subsample_all_examples_static(self):
+ numpy_labels = np.random.permutation(300)
+ indicator = np.array(np.ones(300) == 1, np.bool)
+ numpy_labels = (numpy_labels - 200) > 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 32)
+
+ def test_subsample_selection_dynamic(self):
+ # Test random sampling when only some examples can be sampled:
+ # 100 samples, 20 positives, 10 positives cannot be sampled
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 90
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 80) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 54)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_static(self):
+ # Test random sampling when only some examples can be sampled:
+ # 100 samples, 20 positives, 10 positives cannot be sampled.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 90
+ indicator = np.array(numpy_indicator, np.bool)
+ numpy_labels = (numpy_labels - 80) >= 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 54)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
+
+ def test_subsample_selection_larger_batch_size_dynamic(self):
+ # Test random sampling when total number of examples that can be sampled are
+ # less than batch size:
+ # 100 samples, 50 positives, 40 positives cannot be sampled, batch size 64.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 60
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 50) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 60)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(
+ sum(np.logical_and(np.logical_not(numpy_labels), is_sampled)) == 50)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_larger_batch_size_static(self):
+ # Test random sampling when total number of examples that can be sampled are
+ # less than batch size:
+ # 100 samples, 50 positives, 40 positives cannot be sampled, batch size 64.
+ # It should still return 64 samples, with 4 of them that couldn't have been
+ # sampled.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 60
+ indicator = np.array(numpy_indicator, np.bool)
+ numpy_labels = (numpy_labels - 50) >= 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) >= 10)
+ self.assertTrue(
+ sum(np.logical_and(np.logical_not(numpy_labels), is_sampled)) >= 50)
+ self.assertTrue(sum(np.logical_and(is_sampled, numpy_indicator)) == 60)
+
+ def test_subsample_selection_no_batch_size(self):
+ # Test random sampling when only some examples can be sampled:
+ # 1000 samples, 6 positives (5 can be sampled).
+ numpy_labels = np.arange(1000)
+ numpy_indicator = numpy_labels < 999
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 994) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler(0.01))
+ is_sampled = sampler.subsample(indicator, None, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 500)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 5)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 495)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_no_batch_size_static(self):
+ labels = tf.constant([[True, False, False]])
+ indicator = tf.constant([True, False, True])
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, None, labels)
+
+ def test_raises_error_with_incorrect_label_shape(self):
+ labels = tf.constant([[True, False, False]])
+ indicator = tf.constant([True, False, True])
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, 64, labels)
+
+ def test_raises_error_with_incorrect_indicator_shape(self):
+ labels = tf.constant([True, False, False])
+ indicator = tf.constant([[True, False, True]])
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, 64, labels)
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/batch_multiclass_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/core/batch_multiclass_nms_test.py
new file mode 100644
index 00000000..cd0c56bf
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/batch_multiclass_nms_test.py
@@ -0,0 +1,721 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for google3.third_party.tensorflow_models.object_detection.core.batch_multiclass_nms."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from absl.testing import parameterized
+import numpy as np
+from six.moves import range
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.utils import test_case
+
+
+class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase,
+ parameterized.TestCase):
+
+ @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+ def test_batch_multiclass_nms_with_batch_size_1(self, use_static_shapes):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 999, 2, 1004],
+ [0, 100, 1, 101]]]
+ exp_nms_scores = [[.95, .9, .85, .3]]
+ exp_nms_classes = [[0, 0, 1, 0]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields,
+ num_detections) = post_processing.batch_multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class=max_output_size,
+ max_total_size=max_output_size,
+ use_static_shapes=use_static_shapes)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertEqual(num_detections, [4])
+
+ def test_batch_iou_with_negative_data(self):
+ boxes = tf.constant([[[0, -0.01, 0.1, 1.1], [0, 0.2, 0.2, 5.0],
+ [0, -0.01, 0.1, 1.], [-1, -1, -1, -1]]], tf.float32)
+ iou = post_processing.batch_iou(boxes, boxes)
+ expected_iou = [[[0.99999994, 0.0917431, 0.9099099, -1.],
+ [0.0917431, 1., 0.08154944, -1.],
+ [0.9099099, 0.08154944, 1., -1.], [-1., -1., -1., -1.]]]
+ with self.test_session() as sess:
+ iou = sess.run(iou)
+ self.assertAllClose(iou, expected_iou)
+
+ @parameterized.parameters(False, True)
+ def test_batch_multiclass_nms_with_batch_size_2(self, use_dynamic_map_fn):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ use_dynamic_map_fn=use_dynamic_map_fn)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+
+ def test_batch_multiclass_nms_with_per_batch_clip_window(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ clip_window = tf.constant([0., 0., 200., 200.])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.5, .3, 0, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [0, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ clip_window=clip_window)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 2])
+
+ def test_batch_multiclass_nms_with_per_image_clip_window(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ clip_window = tf.constant([[0., 0., 5., 5.],
+ [0., 0., 200., 200.]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.9, 0., 0., 0.],
+ [.5, .3, 0, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [0, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ clip_window=clip_window)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [1, 2])
+
+ def test_batch_multiclass_nms_with_masks(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = tf.constant([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]],
+ tf.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_masks = np.array([[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ masks=masks)
+
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(), exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(), exp_nms_classes.shape)
+ self.assertAllEqual(nmsed_masks.shape.as_list(), exp_nms_masks.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_additional_fields(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ additional_fields = {
+ 'keypoints': tf.constant(
+ [[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]],
+ tf.float32)
+ }
+ additional_fields['size'] = tf.constant(
+ [[[[6], [8]], [[0], [2]], [[0], [0]], [[0], [0]]],
+ [[[13], [15]], [[8], [10]], [[10], [12]], [[0], [0]]]], tf.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_additional_fields = {
+ 'keypoints': np.array([[[[0, 0], [0, 0]],
+ [[6, 7], [8, 9]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[10, 11], [12, 13]],
+ [[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[0, 0], [0, 0]]]])
+ }
+ exp_nms_additional_fields['size'] = np.array([[[[0], [0]], [[6], [8]],
+ [[0], [0]], [[0], [0]]],
+ [[[10], [12]], [[13], [15]],
+ [[8], [10]], [[0], [0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ additional_fields=additional_fields)
+
+ self.assertIsNone(nmsed_masks)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(), exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(), exp_nms_classes.shape)
+ self.assertEqual(len(nmsed_additional_fields),
+ len(exp_nms_additional_fields))
+ for key in exp_nms_additional_fields:
+ self.assertAllEqual(nmsed_additional_fields[key].shape.as_list(),
+ exp_nms_additional_fields[key].shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_additional_fields,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_additional_fields, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ for key in exp_nms_additional_fields:
+ self.assertAllClose(nmsed_additional_fields[key],
+ exp_nms_additional_fields[key])
+ self.assertAllClose(num_detections, [2, 3])
+
+ def test_batch_multiclass_nms_with_dynamic_batch_size(self):
+ boxes_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2, 4))
+ scores_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2))
+ masks_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2, 2, 2))
+
+ boxes = np.array([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]])
+ scores = np.array([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = np.array([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_masks = np.array([[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes_placeholder, scores_placeholder, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ masks=masks_placeholder)
+
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), [None, 4, 4])
+ self.assertAllEqual(nmsed_scores.shape.as_list(), [None, 4])
+ self.assertAllEqual(nmsed_classes.shape.as_list(), [None, 4])
+ self.assertAllEqual(nmsed_masks.shape.as_list(), [None, 4, 2, 2])
+ self.assertEqual(num_detections.shape.as_list(), [None])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections],
+ feed_dict={boxes_placeholder: boxes,
+ scores_placeholder: scores,
+ masks_placeholder: masks})
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_masks_and_num_valid_boxes(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = tf.constant([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]],
+ tf.float32)
+ num_valid_boxes = tf.constant([1, 1], tf.int32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_nms_scores = [[.9, 0, 0, 0],
+ [.5, 0, 0, 0]]
+ exp_nms_classes = [[0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_nms_masks = [[[[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[8, 9], [10, 11]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ num_valid_boxes=num_valid_boxes, masks=masks)
+
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [1, 1])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_additional_fields_and_num_valid_boxes(
+ self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ additional_fields = {
+ 'keypoints': tf.constant(
+ [[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]],
+ tf.float32)
+ }
+
+ additional_fields['size'] = tf.constant(
+ [[[[7], [9]], [[1], [3]], [[0], [0]], [[0], [0]]],
+ [[[14], [16]], [[9], [11]], [[11], [13]], [[0], [0]]]], tf.float32)
+
+ num_valid_boxes = tf.constant([1, 1], tf.int32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_nms_scores = [[.9, 0, 0, 0],
+ [.5, 0, 0, 0]]
+ exp_nms_classes = [[0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_nms_additional_fields = {
+ 'keypoints': np.array([[[[6, 7], [8, 9]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]]])
+ }
+
+ exp_nms_additional_fields['size'] = np.array([[[[7], [9]], [[0], [0]],
+ [[0], [0]], [[0], [0]]],
+ [[[14], [16]], [[0], [0]],
+ [[0], [0]], [[0], [0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ num_valid_boxes=num_valid_boxes,
+ additional_fields=additional_fields)
+
+ self.assertIsNone(nmsed_masks)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_additional_fields,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_additional_fields, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ for key in exp_nms_additional_fields:
+ self.assertAllClose(nmsed_additional_fields[key],
+ exp_nms_additional_fields[key])
+ self.assertAllClose(num_detections, [1, 1])
+
+ def test_combined_nms_with_batch_size_2(self):
+ """Test use_combined_nms."""
+ boxes = tf.constant([[[[0, 0, 0.1, 0.1], [0, 0, 0.1, 0.1]],
+ [[0, 0.01, 1, 0.11], [0, 0.6, 0.1, 0.7]],
+ [[0, -0.01, 0.1, 0.09], [0, -0.1, 0.1, 0.09]],
+ [[0, 0.11, 0.1, 0.2], [0, 0.11, 0.1, 0.2]]],
+ [[[0, 0, 0.2, 0.2], [0, 0, 0.2, 0.2]],
+ [[0, 0.02, 0.2, 0.22], [0, 0.02, 0.2, 0.22]],
+ [[0, -0.02, 0.2, 0.19], [0, -0.02, 0.2, 0.19]],
+ [[0, 0.21, 0.2, 0.3], [0, 0.21, 0.2, 0.3]]]],
+ tf.float32)
+ scores = tf.constant([[[.1, 0.9], [.75, 0.8],
+ [.6, 0.3], [0.95, 0.1]],
+ [[.1, 0.9], [.75, 0.8],
+ [.6, .3], [.95, .1]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms_corners = np.array([[[0, 0.11, 0.1, 0.2],
+ [0, 0, 0.1, 0.1],
+ [0, 0.6, 0.1, 0.7]],
+ [[0, 0.21, 0.2, 0.3],
+ [0, 0, 0.2, 0.2],
+ [0, 0.02, 0.2, 0.22]]])
+ exp_nms_scores = np.array([[.95, .9, 0.8],
+ [.95, .9, .75]])
+ exp_nms_classes = np.array([[0, 1, 1],
+ [0, 1, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ use_static_shapes=True,
+ use_combined_nms=True)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertListEqual(num_detections.tolist(), [3, 3])
+
+ # TODO(bhattad): Remove conditional after CMLE moves to TF 1.9
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/batcher.py b/Computer Vision/Plant_Disease_Detection_System/core/batcher.py
new file mode 100644
index 00000000..825b90d8
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/batcher.py
@@ -0,0 +1,141 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Provides functions to batch a dictionary of input tensors."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import prefetcher
+
+rt_shape_str = '_runtime_shapes'
+
+
+class BatchQueue(object):
+ """BatchQueue class.
+
+ This class creates a batch queue to asynchronously enqueue tensors_dict.
+ It also adds a FIFO prefetcher so that the batches are readily available
+ for the consumers. Dequeue ops for a BatchQueue object can be created via
+ the Dequeue method which evaluates to a batch of tensor_dict.
+
+ Example input pipeline with batching:
+ ------------------------------------
+ key, string_tensor = slim.parallel_reader.parallel_read(...)
+ tensor_dict = decoder.decode(string_tensor)
+ tensor_dict = preprocessor.preprocess(tensor_dict, ...)
+ batch_queue = batcher.BatchQueue(tensor_dict,
+ batch_size=32,
+ batch_queue_capacity=2000,
+ num_batch_queue_threads=8,
+ prefetch_queue_capacity=20)
+ tensor_dict = batch_queue.dequeue()
+ outputs = Model(tensor_dict)
+ ...
+ -----------------------------------
+
+ Notes:
+ -----
+ This class batches tensors of unequal sizes by zero padding and unpadding
+ them after generating a batch. This can be computationally expensive when
+ batching tensors (such as images) that are of vastly different sizes. So it is
+ recommended that the shapes of such tensors be fully defined in tensor_dict
+ while other lightweight tensors such as bounding box corners and class labels
+ can be of varying sizes. Use either crop or resize operations to fully define
+ the shape of an image in tensor_dict.
+
+ It is also recommended to perform any preprocessing operations on tensors
+ before passing to BatchQueue and subsequently calling the Dequeue method.
+
+ Another caveat is that this class does not read the last batch if it is not
+ full. The current implementation makes it hard to support that use case. So,
+ for evaluation, when it is critical to run all the examples through your
+ network use the input pipeline example mentioned in core/prefetcher.py.
+ """
+
+ def __init__(self, tensor_dict, batch_size, batch_queue_capacity,
+ num_batch_queue_threads, prefetch_queue_capacity):
+ """Constructs a batch queue holding tensor_dict.
+
+ Args:
+ tensor_dict: dictionary of tensors to batch.
+ batch_size: batch size.
+ batch_queue_capacity: max capacity of the queue from which the tensors are
+ batched.
+ num_batch_queue_threads: number of threads to use for batching.
+ prefetch_queue_capacity: max capacity of the queue used to prefetch
+ assembled batches.
+ """
+ # Remember static shapes to set shapes of batched tensors.
+ static_shapes = collections.OrderedDict(
+ {key: tensor.get_shape() for key, tensor in tensor_dict.items()})
+ # Remember runtime shapes to unpad tensors after batching.
+ runtime_shapes = collections.OrderedDict(
+ {(key + rt_shape_str): tf.shape(tensor)
+ for key, tensor in tensor_dict.items()})
+
+ all_tensors = tensor_dict
+ all_tensors.update(runtime_shapes)
+ batched_tensors = tf.train.batch(
+ all_tensors,
+ capacity=batch_queue_capacity,
+ batch_size=batch_size,
+ dynamic_pad=True,
+ num_threads=num_batch_queue_threads)
+
+ self._queue = prefetcher.prefetch(batched_tensors,
+ prefetch_queue_capacity)
+ self._static_shapes = static_shapes
+ self._batch_size = batch_size
+
+ def dequeue(self):
+ """Dequeues a batch of tensor_dict from the BatchQueue.
+
+ TODO: use allow_smaller_final_batch to allow running over the whole eval set
+
+ Returns:
+ A list of tensor_dicts of the requested batch_size.
+ """
+ batched_tensors = self._queue.dequeue()
+ # Separate input tensors from tensors containing their runtime shapes.
+ tensors = {}
+ shapes = {}
+ for key, batched_tensor in batched_tensors.items():
+ unbatched_tensor_list = tf.unstack(batched_tensor)
+ for i, unbatched_tensor in enumerate(unbatched_tensor_list):
+ if rt_shape_str in key:
+ shapes[(key[:-len(rt_shape_str)], i)] = unbatched_tensor
+ else:
+ tensors[(key, i)] = unbatched_tensor
+
+ # Undo that padding using shapes and create a list of size `batch_size` that
+ # contains tensor dictionaries.
+ tensor_dict_list = []
+ batch_size = self._batch_size
+ for batch_id in range(batch_size):
+ tensor_dict = {}
+ for key in self._static_shapes:
+ tensor_dict[key] = tf.slice(tensors[(key, batch_id)],
+ tf.zeros_like(shapes[(key, batch_id)]),
+ shapes[(key, batch_id)])
+ tensor_dict[key].set_shape(self._static_shapes[key])
+ tensor_dict_list.append(tensor_dict)
+
+ return tensor_dict_list
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/batcher_test.py b/Computer Vision/Plant_Disease_Detection_System/core/batcher_test.py
new file mode 100644
index 00000000..a6c9faf2
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/batcher_test.py
@@ -0,0 +1,163 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.batcher."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import batcher
+
+slim = tf.contrib.slim
+
+
+class BatcherTest(tf.test.TestCase):
+
+ def test_batch_and_unpad_2d_tensors_of_different_sizes_in_1st_dimension(self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ boxes = tf.tile(
+ tf.reshape(tf.range(4), [1, 4]), tf.stack([counter, tf.constant(1)]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'boxes': boxes},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, 4], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.tile(np.arange(4), (i, 1)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batch_and_unpad_2d_tensors_of_different_sizes_in_all_dimensions(
+ self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ image = tf.reshape(
+ tf.range(counter * counter), tf.stack([counter, counter]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, None], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(i * i).reshape((i, i)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batch_and_unpad_2d_tensors_of_same_size_in_all_dimensions(self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(1, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 1)
+ image = tf.reshape(tf.range(1, 13), [4, 3]) * counter
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([4, 3], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 1
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(1, 13).reshape((4, 3)) * i)
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batcher_when_batch_size_is_one(self):
+ with self.test_session() as sess:
+ batch_size = 1
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ image = tf.reshape(
+ tf.range(counter * counter), tf.stack([counter, counter]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, None], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(i * i).reshape((i, i)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_coder.py b/Computer Vision/Plant_Disease_Detection_System/core/box_coder.py
new file mode 100644
index 00000000..82f084d6
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_coder.py
@@ -0,0 +1,158 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base box coder.
+
+Box coders convert between coordinate frames, namely image-centric
+(with (0,0) on the top left of image) and anchor-centric (with (0,0) being
+defined by a specific anchor).
+
+Users of a BoxCoder can call two methods:
+ encode: which encodes a box with respect to a given anchor
+ (or rather, a tensor of boxes wrt a corresponding tensor of anchors) and
+ decode: which inverts this encoding with a decode operation.
+In both cases, the arguments are assumed to be in 1-1 correspondence already;
+it is not the job of a BoxCoder to perform matching.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+from abc import abstractproperty
+
+import six
+import tensorflow as tf
+
+from object_detection.utils import shape_utils
+
+
+# Box coder types.
+FASTER_RCNN = 'faster_rcnn'
+KEYPOINT = 'keypoint'
+MEAN_STDDEV = 'mean_stddev'
+SQUARE = 'square'
+
+
+class BoxCoder(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for box coder."""
+
+ @abstractproperty
+ def code_size(self):
+ """Return the size of each code.
+
+ This number is a constant and should agree with the output of the `encode`
+ op (e.g. if rel_codes is the output of self.encode(...), then it should have
+ shape [N, code_size()]). This abstractproperty should be overridden by
+ implementations.
+
+ Returns:
+ an integer constant
+ """
+ pass
+
+ def encode(self, boxes, anchors):
+ """Encode a box list relative to an anchor collection.
+
+ Args:
+ boxes: BoxList holding N boxes to be encoded
+ anchors: BoxList of N anchors
+
+ Returns:
+ a tensor representing N relative-encoded boxes
+ """
+ with tf.name_scope('Encode'):
+ return self._encode(boxes, anchors)
+
+ def decode(self, rel_codes, anchors):
+ """Decode boxes that are encoded relative to an anchor collection.
+
+ Args:
+ rel_codes: a tensor representing N relative-encoded boxes
+ anchors: BoxList of anchors
+
+ Returns:
+ boxlist: BoxList holding N boxes encoded in the ordinary way (i.e.,
+ with corners y_min, x_min, y_max, x_max)
+ """
+ with tf.name_scope('Decode'):
+ return self._decode(rel_codes, anchors)
+
+ @abstractmethod
+ def _encode(self, boxes, anchors):
+ """Method to be overriden by implementations.
+
+ Args:
+ boxes: BoxList holding N boxes to be encoded
+ anchors: BoxList of N anchors
+
+ Returns:
+ a tensor representing N relative-encoded boxes
+ """
+ pass
+
+ @abstractmethod
+ def _decode(self, rel_codes, anchors):
+ """Method to be overriden by implementations.
+
+ Args:
+ rel_codes: a tensor representing N relative-encoded boxes
+ anchors: BoxList of anchors
+
+ Returns:
+ boxlist: BoxList holding N boxes encoded in the ordinary way (i.e.,
+ with corners y_min, x_min, y_max, x_max)
+ """
+ pass
+
+
+def batch_decode(encoded_boxes, box_coder, anchors):
+ """Decode a batch of encoded boxes.
+
+ This op takes a batch of encoded bounding boxes and transforms
+ them to a batch of bounding boxes specified by their corners in
+ the order of [y_min, x_min, y_max, x_max].
+
+ Args:
+ encoded_boxes: a float32 tensor of shape [batch_size, num_anchors,
+ code_size] representing the location of the objects.
+ box_coder: a BoxCoder object.
+ anchors: a BoxList of anchors used to encode `encoded_boxes`.
+
+ Returns:
+ decoded_boxes: a float32 tensor of shape [batch_size, num_anchors,
+ coder_size] representing the corners of the objects in the order
+ of [y_min, x_min, y_max, x_max].
+
+ Raises:
+ ValueError: if batch sizes of the inputs are inconsistent, or if
+ the number of anchors inferred from encoded_boxes and anchors are
+ inconsistent.
+ """
+ encoded_boxes.get_shape().assert_has_rank(3)
+ if (shape_utils.get_dim_as_int(encoded_boxes.get_shape()[1])
+ != anchors.num_boxes_static()):
+ raise ValueError('The number of anchors inferred from encoded_boxes'
+ ' and anchors are inconsistent: shape[1] of encoded_boxes'
+ ' %s should be equal to the number of anchors: %s.' %
+ (shape_utils.get_dim_as_int(encoded_boxes.get_shape()[1]),
+ anchors.num_boxes_static()))
+
+ decoded_boxes = tf.stack([
+ box_coder.decode(boxes, anchors).get()
+ for boxes in tf.unstack(encoded_boxes)
+ ])
+ return decoded_boxes
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_coder_test.py b/Computer Vision/Plant_Disease_Detection_System/core/box_coder_test.py
new file mode 100644
index 00000000..c087a325
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_coder_test.py
@@ -0,0 +1,61 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_coder."""
+
+import tensorflow as tf
+
+from object_detection.core import box_coder
+from object_detection.core import box_list
+
+
+class MockBoxCoder(box_coder.BoxCoder):
+ """Test BoxCoder that encodes/decodes using the multiply-by-two function."""
+
+ def code_size(self):
+ return 4
+
+ def _encode(self, boxes, anchors):
+ return 2.0 * boxes.get()
+
+ def _decode(self, rel_codes, anchors):
+ return box_list.BoxList(rel_codes / 2.0)
+
+
+class BoxCoderTest(tf.test.TestCase):
+
+ def test_batch_decode(self):
+ mock_anchor_corners = tf.constant(
+ [[0, 0.1, 0.2, 0.3], [0.2, 0.4, 0.4, 0.6]], tf.float32)
+ mock_anchors = box_list.BoxList(mock_anchor_corners)
+ mock_box_coder = MockBoxCoder()
+
+ expected_boxes = [[[0.0, 0.1, 0.5, 0.6], [0.5, 0.6, 0.7, 0.8]],
+ [[0.1, 0.2, 0.3, 0.4], [0.7, 0.8, 0.9, 1.0]]]
+
+ encoded_boxes_list = [mock_box_coder.encode(
+ box_list.BoxList(tf.constant(boxes)), mock_anchors)
+ for boxes in expected_boxes]
+ encoded_boxes = tf.stack(encoded_boxes_list)
+ decoded_boxes = box_coder.batch_decode(
+ encoded_boxes, mock_box_coder, mock_anchors)
+
+ with self.test_session() as sess:
+ decoded_boxes_result = sess.run(decoded_boxes)
+ self.assertAllClose(expected_boxes, decoded_boxes_result)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_list.py b/Computer Vision/Plant_Disease_Detection_System/core/box_list.py
new file mode 100644
index 00000000..cda75755
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_list.py
@@ -0,0 +1,210 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Bounding Box List definition.
+
+BoxList represents a list of bounding boxes as tensorflow
+tensors, where each bounding box is represented as a row of 4 numbers,
+[y_min, x_min, y_max, x_max]. It is assumed that all bounding boxes
+within a given list correspond to a single image. See also
+box_list_ops.py for common box related operations (such as area, iou, etc).
+
+Optionally, users can add additional related fields (such as weights).
+We assume the following things to be true about fields:
+* they correspond to boxes in the box_list along the 0th dimension
+* they have inferrable rank at graph construction time
+* all dimensions except for possibly the 0th can be inferred
+ (i.e., not None) at graph construction time.
+
+Some other notes:
+ * Following tensorflow conventions, we use height, width ordering,
+ and correspondingly, y,x (or ymin, xmin, ymax, xmax) ordering
+ * Tensors are always provided as (flat) [N, 4] tensors.
+"""
+
+import tensorflow as tf
+
+from object_detection.utils import shape_utils
+
+
+class BoxList(object):
+ """Box collection."""
+
+ def __init__(self, boxes):
+ """Constructs box collection.
+
+ Args:
+ boxes: a tensor of shape [N, 4] representing box corners
+
+ Raises:
+ ValueError: if invalid dimensions for bbox data or if bbox data is not in
+ float32 format.
+ """
+ if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
+ raise ValueError('Invalid dimensions for box data: {}'.format(
+ boxes.shape))
+ if boxes.dtype != tf.float32:
+ raise ValueError('Invalid tensor type: should be tf.float32')
+ self.data = {'boxes': boxes}
+
+ def num_boxes(self):
+ """Returns number of boxes held in collection.
+
+ Returns:
+ a tensor representing the number of boxes held in the collection.
+ """
+ return tf.shape(self.data['boxes'])[0]
+
+ def num_boxes_static(self):
+ """Returns number of boxes held in collection.
+
+ This number is inferred at graph construction time rather than run-time.
+
+ Returns:
+ Number of boxes held in collection (integer) or None if this is not
+ inferrable at graph construction time.
+ """
+ return shape_utils.get_dim_as_int(self.data['boxes'].get_shape()[0])
+
+ def get_all_fields(self):
+ """Returns all fields."""
+ return self.data.keys()
+
+ def get_extra_fields(self):
+ """Returns all non-box fields (i.e., everything not named 'boxes')."""
+ return [k for k in self.data.keys() if k != 'boxes']
+
+ def add_field(self, field, field_data):
+ """Add field to box list.
+
+ This method can be used to add related box data such as
+ weights/labels, etc.
+
+ Args:
+ field: a string key to access the data via `get`
+ field_data: a tensor containing the data to store in the BoxList
+ """
+ self.data[field] = field_data
+
+ def has_field(self, field):
+ return field in self.data
+
+ def get(self):
+ """Convenience function for accessing box coordinates.
+
+ Returns:
+ a tensor with shape [N, 4] representing box coordinates.
+ """
+ return self.get_field('boxes')
+
+ def set(self, boxes):
+ """Convenience function for setting box coordinates.
+
+ Args:
+ boxes: a tensor of shape [N, 4] representing box corners
+
+ Raises:
+ ValueError: if invalid dimensions for bbox data
+ """
+ if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
+ raise ValueError('Invalid dimensions for box data.')
+ self.data['boxes'] = boxes
+
+ def get_field(self, field):
+ """Accesses a box collection and associated fields.
+
+ This function returns specified field with object; if no field is specified,
+ it returns the box coordinates.
+
+ Args:
+ field: this optional string parameter can be used to specify
+ a related field to be accessed.
+
+ Returns:
+ a tensor representing the box collection or an associated field.
+
+ Raises:
+ ValueError: if invalid field
+ """
+ if not self.has_field(field):
+ raise ValueError('field ' + str(field) + ' does not exist')
+ return self.data[field]
+
+ def set_field(self, field, value):
+ """Sets the value of a field.
+
+ Updates the field of a box_list with a given value.
+
+ Args:
+ field: (string) name of the field to set value.
+ value: the value to assign to the field.
+
+ Raises:
+ ValueError: if the box_list does not have specified field.
+ """
+ if not self.has_field(field):
+ raise ValueError('field %s does not exist' % field)
+ self.data[field] = value
+
+ def get_center_coordinates_and_sizes(self, scope=None):
+ """Computes the center coordinates, height and width of the boxes.
+
+ Args:
+ scope: name scope of the function.
+
+ Returns:
+ a list of 4 1-D tensors [ycenter, xcenter, height, width].
+ """
+ with tf.name_scope(scope, 'get_center_coordinates_and_sizes'):
+ box_corners = self.get()
+ ymin, xmin, ymax, xmax = tf.unstack(tf.transpose(box_corners))
+ width = xmax - xmin
+ height = ymax - ymin
+ ycenter = ymin + height / 2.
+ xcenter = xmin + width / 2.
+ return [ycenter, xcenter, height, width]
+
+ def transpose_coordinates(self, scope=None):
+ """Transpose the coordinate representation in a boxlist.
+
+ Args:
+ scope: name scope of the function.
+ """
+ with tf.name_scope(scope, 'transpose_coordinates'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=self.get(), num_or_size_splits=4, axis=1)
+ self.set(tf.concat([x_min, y_min, x_max, y_max], 1))
+
+ def as_tensor_dict(self, fields=None):
+ """Retrieves specified fields as a dictionary of tensors.
+
+ Args:
+ fields: (optional) list of fields to return in the dictionary.
+ If None (default), all fields are returned.
+
+ Returns:
+ tensor_dict: A dictionary of tensors specified by fields.
+
+ Raises:
+ ValueError: if specified field is not contained in boxlist.
+ """
+ tensor_dict = {}
+ if fields is None:
+ fields = self.get_all_fields()
+ for field in fields:
+ if not self.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ tensor_dict[field] = self.get_field(field)
+ return tensor_dict
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops.py b/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops.py
new file mode 100644
index 00000000..0bd3788f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops.py
@@ -0,0 +1,1141 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Bounding Box List operations.
+
+Example box operations that are supported:
+ * areas: compute bounding box areas
+ * iou: pairwise intersection-over-union scores
+ * sq_dist: pairwise distances between bounding boxes
+
+Whenever box_list_ops functions output a BoxList, the fields of the incoming
+BoxList are retained unless documented otherwise.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.utils import ops
+from object_detection.utils import shape_utils
+
+
+class SortOrder(object):
+ """Enum class for sort order.
+
+ Attributes:
+ ascend: ascend order.
+ descend: descend order.
+ """
+ ascend = 1
+ descend = 2
+
+
+def area(boxlist, scope=None):
+ """Computes area of boxes.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing box areas.
+ """
+ with tf.name_scope(scope, 'Area'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ return tf.squeeze((y_max - y_min) * (x_max - x_min), [1])
+
+
+def height_width(boxlist, scope=None):
+ """Computes height and width of boxes in boxlist.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ Height: A tensor with shape [N] representing box heights.
+ Width: A tensor with shape [N] representing box widths.
+ """
+ with tf.name_scope(scope, 'HeightWidth'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ return tf.squeeze(y_max - y_min, [1]), tf.squeeze(x_max - x_min, [1])
+
+
+def scale(boxlist, y_scale, x_scale, scope=None):
+ """scale box coordinates in x and y dimensions.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ y_scale: (float) scalar tensor
+ x_scale: (float) scalar tensor
+ scope: name scope.
+
+ Returns:
+ boxlist: BoxList holding N boxes
+ """
+ with tf.name_scope(scope, 'Scale'):
+ y_scale = tf.cast(y_scale, tf.float32)
+ x_scale = tf.cast(x_scale, tf.float32)
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ y_min = y_scale * y_min
+ y_max = y_scale * y_max
+ x_min = x_scale * x_min
+ x_max = x_scale * x_max
+ scaled_boxlist = box_list.BoxList(
+ tf.concat([y_min, x_min, y_max, x_max], 1))
+ return _copy_extra_fields(scaled_boxlist, boxlist)
+
+
+def clip_to_window(boxlist, window, filter_nonoverlapping=True, scope=None):
+ """Clip bounding boxes to a window.
+
+ This op clips any input bounding boxes (represented by bounding box
+ corners) to a window, optionally filtering out boxes that do not
+ overlap at all with the window.
+
+ Args:
+ boxlist: BoxList holding M_in boxes
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window to which the op should clip boxes.
+ filter_nonoverlapping: whether to filter out boxes that do not overlap at
+ all with the window.
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M_out boxes where M_out <= M_in
+ """
+ with tf.name_scope(scope, 'ClipToWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ y_min_clipped = tf.maximum(tf.minimum(y_min, win_y_max), win_y_min)
+ y_max_clipped = tf.maximum(tf.minimum(y_max, win_y_max), win_y_min)
+ x_min_clipped = tf.maximum(tf.minimum(x_min, win_x_max), win_x_min)
+ x_max_clipped = tf.maximum(tf.minimum(x_max, win_x_max), win_x_min)
+ clipped = box_list.BoxList(
+ tf.concat([y_min_clipped, x_min_clipped, y_max_clipped, x_max_clipped],
+ 1))
+ clipped = _copy_extra_fields(clipped, boxlist)
+ if filter_nonoverlapping:
+ areas = area(clipped)
+ nonzero_area_indices = tf.cast(
+ tf.reshape(tf.where(tf.greater(areas, 0.0)), [-1]), tf.int32)
+ clipped = gather(clipped, nonzero_area_indices)
+ return clipped
+
+
+def prune_outside_window(boxlist, window, scope=None):
+ """Prunes bounding boxes that fall outside a given window.
+
+ This function prunes bounding boxes that even partially fall outside the given
+ window. See also clip_to_window which only prunes bounding boxes that fall
+ completely outside the window, and clips any bounding boxes that partially
+ overflow.
+
+ Args:
+ boxlist: a BoxList holding M_in boxes.
+ window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax]
+ of the window
+ scope: name scope.
+
+ Returns:
+ pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in
+ valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
+ in the input tensor.
+ """
+ with tf.name_scope(scope, 'PruneOutsideWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ coordinate_violations = tf.concat([
+ tf.less(y_min, win_y_min), tf.less(x_min, win_x_min),
+ tf.greater(y_max, win_y_max), tf.greater(x_max, win_x_max)
+ ], 1)
+ valid_indices = tf.reshape(
+ tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1])
+ return gather(boxlist, valid_indices), valid_indices
+
+
+def prune_completely_outside_window(boxlist, window, scope=None):
+ """Prunes bounding boxes that fall completely outside of the given window.
+
+ The function clip_to_window prunes bounding boxes that fall
+ completely outside the window, but also clips any bounding boxes that
+ partially overflow. This function does not clip partially overflowing boxes.
+
+ Args:
+ boxlist: a BoxList holding M_in boxes.
+ window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax]
+ of the window
+ scope: name scope.
+
+ Returns:
+ pruned_boxlist: a new BoxList with all bounding boxes partially or fully in
+ the window.
+ valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
+ in the input tensor.
+ """
+ with tf.name_scope(scope, 'PruneCompleteleyOutsideWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ coordinate_violations = tf.concat([
+ tf.greater_equal(y_min, win_y_max), tf.greater_equal(x_min, win_x_max),
+ tf.less_equal(y_max, win_y_min), tf.less_equal(x_max, win_x_min)
+ ], 1)
+ valid_indices = tf.reshape(
+ tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1])
+ return gather(boxlist, valid_indices), valid_indices
+
+
+def intersection(boxlist1, boxlist2, scope=None):
+ """Compute pairwise intersection areas between boxes.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise intersections
+ """
+ with tf.name_scope(scope, 'Intersection'):
+ y_min1, x_min1, y_max1, x_max1 = tf.split(
+ value=boxlist1.get(), num_or_size_splits=4, axis=1)
+ y_min2, x_min2, y_max2, x_max2 = tf.split(
+ value=boxlist2.get(), num_or_size_splits=4, axis=1)
+ all_pairs_min_ymax = tf.minimum(y_max1, tf.transpose(y_max2))
+ all_pairs_max_ymin = tf.maximum(y_min1, tf.transpose(y_min2))
+ intersect_heights = tf.maximum(0.0, all_pairs_min_ymax - all_pairs_max_ymin)
+ all_pairs_min_xmax = tf.minimum(x_max1, tf.transpose(x_max2))
+ all_pairs_max_xmin = tf.maximum(x_min1, tf.transpose(x_min2))
+ intersect_widths = tf.maximum(0.0, all_pairs_min_xmax - all_pairs_max_xmin)
+ return intersect_heights * intersect_widths
+
+
+def matched_intersection(boxlist1, boxlist2, scope=None):
+ """Compute intersection areas between corresponding boxes in two boxlists.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing pairwise intersections
+ """
+ with tf.name_scope(scope, 'MatchedIntersection'):
+ y_min1, x_min1, y_max1, x_max1 = tf.split(
+ value=boxlist1.get(), num_or_size_splits=4, axis=1)
+ y_min2, x_min2, y_max2, x_max2 = tf.split(
+ value=boxlist2.get(), num_or_size_splits=4, axis=1)
+ min_ymax = tf.minimum(y_max1, y_max2)
+ max_ymin = tf.maximum(y_min1, y_min2)
+ intersect_heights = tf.maximum(0.0, min_ymax - max_ymin)
+ min_xmax = tf.minimum(x_max1, x_max2)
+ max_xmin = tf.maximum(x_min1, x_min2)
+ intersect_widths = tf.maximum(0.0, min_xmax - max_xmin)
+ return tf.reshape(intersect_heights * intersect_widths, [-1])
+
+
+def iou(boxlist1, boxlist2, scope=None):
+ """Computes pairwise intersection-over-union between box collections.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise iou scores.
+ """
+ with tf.name_scope(scope, 'IOU'):
+ intersections = intersection(boxlist1, boxlist2)
+ areas1 = area(boxlist1)
+ areas2 = area(boxlist2)
+ unions = (
+ tf.expand_dims(areas1, 1) + tf.expand_dims(areas2, 0) - intersections)
+ return tf.where(
+ tf.equal(intersections, 0.0),
+ tf.zeros_like(intersections), tf.truediv(intersections, unions))
+
+
+def matched_iou(boxlist1, boxlist2, scope=None):
+ """Compute intersection-over-union between corresponding boxes in boxlists.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing pairwise iou scores.
+ """
+ with tf.name_scope(scope, 'MatchedIOU'):
+ intersections = matched_intersection(boxlist1, boxlist2)
+ areas1 = area(boxlist1)
+ areas2 = area(boxlist2)
+ unions = areas1 + areas2 - intersections
+ return tf.where(
+ tf.equal(intersections, 0.0),
+ tf.zeros_like(intersections), tf.truediv(intersections, unions))
+
+
+def ioa(boxlist1, boxlist2, scope=None):
+ """Computes pairwise intersection-over-area between box collections.
+
+ intersection-over-area (IOA) between two boxes box1 and box2 is defined as
+ their intersection area over box2's area. Note that ioa is not symmetric,
+ that is, ioa(box1, box2) != ioa(box2, box1).
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise ioa scores.
+ """
+ with tf.name_scope(scope, 'IOA'):
+ intersections = intersection(boxlist1, boxlist2)
+ areas = tf.expand_dims(area(boxlist2), 0)
+ return tf.truediv(intersections, areas)
+
+
+def prune_non_overlapping_boxes(
+ boxlist1, boxlist2, min_overlap=0.0, scope=None):
+ """Prunes the boxes in boxlist1 that overlap less than thresh with boxlist2.
+
+ For each box in boxlist1, we want its IOA to be more than minoverlap with
+ at least one of the boxes in boxlist2. If it does not, we remove it.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+ min_overlap: Minimum required overlap between boxes, to count them as
+ overlapping.
+ scope: name scope.
+
+ Returns:
+ new_boxlist1: A pruned boxlist with size [N', 4].
+ keep_inds: A tensor with shape [N'] indexing kept bounding boxes in the
+ first input BoxList `boxlist1`.
+ """
+ with tf.name_scope(scope, 'PruneNonOverlappingBoxes'):
+ ioa_ = ioa(boxlist2, boxlist1) # [M, N] tensor
+ ioa_ = tf.reduce_max(ioa_, reduction_indices=[0]) # [N] tensor
+ keep_bool = tf.greater_equal(ioa_, tf.constant(min_overlap))
+ keep_inds = tf.squeeze(tf.where(keep_bool), axis=[1])
+ new_boxlist1 = gather(boxlist1, keep_inds)
+ return new_boxlist1, keep_inds
+
+
+def prune_small_boxes(boxlist, min_side, scope=None):
+ """Prunes small boxes in the boxlist which have a side smaller than min_side.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ min_side: Minimum width AND height of box to survive pruning.
+ scope: name scope.
+
+ Returns:
+ A pruned boxlist.
+ """
+ with tf.name_scope(scope, 'PruneSmallBoxes'):
+ height, width = height_width(boxlist)
+ is_valid = tf.logical_and(tf.greater_equal(width, min_side),
+ tf.greater_equal(height, min_side))
+ return gather(boxlist, tf.reshape(tf.where(is_valid), [-1]))
+
+
+def change_coordinate_frame(boxlist, window, scope=None):
+ """Change coordinate frame of the boxlist to be relative to window's frame.
+
+ Given a window of the form [ymin, xmin, ymax, xmax],
+ changes bounding box coordinates from boxlist to be relative to this window
+ (e.g., the min corner maps to (0,0) and the max corner maps to (1,1)).
+
+ An example use case is data augmentation: where we are given groundtruth
+ boxes (boxlist) and would like to randomly crop the image to some
+ window (window). In this case we need to change the coordinate frame of
+ each groundtruth box to be relative to this new window.
+
+ Args:
+ boxlist: A BoxList object holding N boxes.
+ window: A rank 1 tensor [4].
+ scope: name scope.
+
+ Returns:
+ Returns a BoxList object with N boxes.
+ """
+ with tf.name_scope(scope, 'ChangeCoordinateFrame'):
+ win_height = window[2] - window[0]
+ win_width = window[3] - window[1]
+ boxlist_new = scale(box_list.BoxList(
+ boxlist.get() - [window[0], window[1], window[0], window[1]]),
+ 1.0 / win_height, 1.0 / win_width)
+ boxlist_new = _copy_extra_fields(boxlist_new, boxlist)
+ return boxlist_new
+
+
+def sq_dist(boxlist1, boxlist2, scope=None):
+ """Computes the pairwise squared distances between box corners.
+
+ This op treats each box as if it were a point in a 4d Euclidean space and
+ computes pairwise squared distances.
+
+ Mathematically, we are given two matrices of box coordinates X and Y,
+ where X(i,:) is the i'th row of X, containing the 4 numbers defining the
+ corners of the i'th box in boxlist1. Similarly Y(j,:) corresponds to
+ boxlist2. We compute
+ Z(i,j) = ||X(i,:) - Y(j,:)||^2
+ = ||X(i,:)||^2 + ||Y(j,:)||^2 - 2 X(i,:)' * Y(j,:),
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise distances
+ """
+ with tf.name_scope(scope, 'SqDist'):
+ sqnorm1 = tf.reduce_sum(tf.square(boxlist1.get()), 1, keep_dims=True)
+ sqnorm2 = tf.reduce_sum(tf.square(boxlist2.get()), 1, keep_dims=True)
+ innerprod = tf.matmul(boxlist1.get(), boxlist2.get(),
+ transpose_a=False, transpose_b=True)
+ return sqnorm1 + tf.transpose(sqnorm2) - 2.0 * innerprod
+
+
+def boolean_mask(boxlist, indicator, fields=None, scope=None,
+ use_static_shapes=False, indicator_sum=None):
+ """Select boxes from BoxList according to indicator and return new BoxList.
+
+ `boolean_mask` returns the subset of boxes that are marked as "True" by the
+ indicator tensor. By default, `boolean_mask` returns boxes corresponding to
+ the input index list, as well as all additional fields stored in the boxlist
+ (indexing into the first dimension). However one can optionally only draw
+ from a subset of fields.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ indicator: a rank-1 boolean tensor
+ fields: (optional) list of fields to also gather from. If None (default),
+ all fields are gathered from. Pass an empty fields list to only gather
+ the box coordinates.
+ scope: name scope.
+ use_static_shapes: Whether to use an implementation with static shape
+ gurantees.
+ indicator_sum: An integer containing the sum of `indicator` vector. Only
+ required if `use_static_shape` is True.
+
+ Returns:
+ subboxlist: a BoxList corresponding to the subset of the input BoxList
+ specified by indicator
+ Raises:
+ ValueError: if `indicator` is not a rank-1 boolean tensor.
+ """
+ with tf.name_scope(scope, 'BooleanMask'):
+ if indicator.shape.ndims != 1:
+ raise ValueError('indicator should have rank 1')
+ if indicator.dtype != tf.bool:
+ raise ValueError('indicator should be a boolean tensor')
+ if use_static_shapes:
+ if not (indicator_sum and isinstance(indicator_sum, int)):
+ raise ValueError('`indicator_sum` must be a of type int')
+ selected_positions = tf.cast(indicator, dtype=tf.float32)
+ indexed_positions = tf.cast(
+ tf.multiply(
+ tf.cumsum(selected_positions), selected_positions),
+ dtype=tf.int32)
+ one_hot_selector = tf.one_hot(
+ indexed_positions - 1, indicator_sum, dtype=tf.float32)
+ sampled_indices = tf.cast(
+ tf.tensordot(
+ tf.cast(tf.range(tf.shape(indicator)[0]), dtype=tf.float32),
+ one_hot_selector,
+ axes=[0, 0]),
+ dtype=tf.int32)
+ return gather(boxlist, sampled_indices, use_static_shapes=True)
+ else:
+ subboxlist = box_list.BoxList(tf.boolean_mask(boxlist.get(), indicator))
+ if fields is None:
+ fields = boxlist.get_extra_fields()
+ for field in fields:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ subfieldlist = tf.boolean_mask(boxlist.get_field(field), indicator)
+ subboxlist.add_field(field, subfieldlist)
+ return subboxlist
+
+
+def gather(boxlist, indices, fields=None, scope=None, use_static_shapes=False):
+ """Gather boxes from BoxList according to indices and return new BoxList.
+
+ By default, `gather` returns boxes corresponding to the input index list, as
+ well as all additional fields stored in the boxlist (indexing into the
+ first dimension). However one can optionally only gather from a
+ subset of fields.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ indices: a rank-1 tensor of type int32 / int64
+ fields: (optional) list of fields to also gather from. If None (default),
+ all fields are gathered from. Pass an empty fields list to only gather
+ the box coordinates.
+ scope: name scope.
+ use_static_shapes: Whether to use an implementation with static shape
+ gurantees.
+
+ Returns:
+ subboxlist: a BoxList corresponding to the subset of the input BoxList
+ specified by indices
+ Raises:
+ ValueError: if specified field is not contained in boxlist or if the
+ indices are not of type int32
+ """
+ with tf.name_scope(scope, 'Gather'):
+ if len(indices.shape.as_list()) != 1:
+ raise ValueError('indices should have rank 1')
+ if indices.dtype != tf.int32 and indices.dtype != tf.int64:
+ raise ValueError('indices should be an int32 / int64 tensor')
+ gather_op = tf.gather
+ if use_static_shapes:
+ gather_op = ops.matmul_gather_on_zeroth_axis
+ subboxlist = box_list.BoxList(gather_op(boxlist.get(), indices))
+ if fields is None:
+ fields = boxlist.get_extra_fields()
+ fields += ['boxes']
+ for field in fields:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ subfieldlist = gather_op(boxlist.get_field(field), indices)
+ subboxlist.add_field(field, subfieldlist)
+ return subboxlist
+
+
+def concatenate(boxlists, fields=None, scope=None):
+ """Concatenate list of BoxLists.
+
+ This op concatenates a list of input BoxLists into a larger BoxList. It also
+ handles concatenation of BoxList fields as long as the field tensor shapes
+ are equal except for the first dimension.
+
+ Args:
+ boxlists: list of BoxList objects
+ fields: optional list of fields to also concatenate. By default, all
+ fields from the first BoxList in the list are included in the
+ concatenation.
+ scope: name scope.
+
+ Returns:
+ a BoxList with number of boxes equal to
+ sum([boxlist.num_boxes() for boxlist in BoxList])
+ Raises:
+ ValueError: if boxlists is invalid (i.e., is not a list, is empty, or
+ contains non BoxList objects), or if requested fields are not contained in
+ all boxlists
+ """
+ with tf.name_scope(scope, 'Concatenate'):
+ if not isinstance(boxlists, list):
+ raise ValueError('boxlists should be a list')
+ if not boxlists:
+ raise ValueError('boxlists should have nonzero length')
+ for boxlist in boxlists:
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('all elements of boxlists should be BoxList objects')
+ concatenated = box_list.BoxList(
+ tf.concat([boxlist.get() for boxlist in boxlists], 0))
+ if fields is None:
+ fields = boxlists[0].get_extra_fields()
+ for field in fields:
+ first_field_shape = boxlists[0].get_field(field).get_shape().as_list()
+ first_field_shape[0] = -1
+ if None in first_field_shape:
+ raise ValueError('field %s must have fully defined shape except for the'
+ ' 0th dimension.' % field)
+ for boxlist in boxlists:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all requested fields')
+ field_shape = boxlist.get_field(field).get_shape().as_list()
+ field_shape[0] = -1
+ if field_shape != first_field_shape:
+ raise ValueError('field %s must have same shape for all boxlists '
+ 'except for the 0th dimension.' % field)
+ concatenated_field = tf.concat(
+ [boxlist.get_field(field) for boxlist in boxlists], 0)
+ concatenated.add_field(field, concatenated_field)
+ return concatenated
+
+
+def sort_by_field(boxlist, field, order=SortOrder.descend, scope=None):
+ """Sort boxes and associated fields according to a scalar field.
+
+ A common use case is reordering the boxes according to descending scores.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ field: A BoxList field for sorting and reordering the BoxList.
+ order: (Optional) descend or ascend. Default is descend.
+ scope: name scope.
+
+ Returns:
+ sorted_boxlist: A sorted BoxList with the field in the specified order.
+
+ Raises:
+ ValueError: if specified field does not exist
+ ValueError: if the order is not either descend or ascend
+ """
+ with tf.name_scope(scope, 'SortByField'):
+ if order != SortOrder.descend and order != SortOrder.ascend:
+ raise ValueError('Invalid sort order')
+
+ field_to_sort = boxlist.get_field(field)
+ if len(field_to_sort.shape.as_list()) != 1:
+ raise ValueError('Field should have rank 1')
+
+ num_boxes = boxlist.num_boxes()
+ num_entries = tf.size(field_to_sort)
+ length_assert = tf.Assert(
+ tf.equal(num_boxes, num_entries),
+ ['Incorrect field size: actual vs expected.', num_entries, num_boxes])
+
+ with tf.control_dependencies([length_assert]):
+ _, sorted_indices = tf.nn.top_k(field_to_sort, num_boxes, sorted=True)
+
+ if order == SortOrder.ascend:
+ sorted_indices = tf.reverse_v2(sorted_indices, [0])
+
+ return gather(boxlist, sorted_indices)
+
+
+def visualize_boxes_in_image(image, boxlist, normalized=False, scope=None):
+ """Overlay bounding box list on image.
+
+ Currently this visualization plots a 1 pixel thick red bounding box on top
+ of the image. Note that tf.image.draw_bounding_boxes essentially is
+ 1 indexed.
+
+ Args:
+ image: an image tensor with shape [height, width, 3]
+ boxlist: a BoxList
+ normalized: (boolean) specify whether corners are to be interpreted
+ as absolute coordinates in image space or normalized with respect to the
+ image size.
+ scope: name scope.
+
+ Returns:
+ image_and_boxes: an image tensor with shape [height, width, 3]
+ """
+ with tf.name_scope(scope, 'VisualizeBoxesInImage'):
+ if not normalized:
+ height, width, _ = tf.unstack(tf.shape(image))
+ boxlist = scale(boxlist,
+ 1.0 / tf.cast(height, tf.float32),
+ 1.0 / tf.cast(width, tf.float32))
+ corners = tf.expand_dims(boxlist.get(), 0)
+ image = tf.expand_dims(image, 0)
+ return tf.squeeze(tf.image.draw_bounding_boxes(image, corners), [0])
+
+
+def filter_field_value_equals(boxlist, field, value, scope=None):
+ """Filter to keep only boxes with field entries equal to the given value.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ field: field name for filtering.
+ value: scalar value.
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= N
+
+ Raises:
+ ValueError: if boxlist not a BoxList object or if it does not have
+ the specified field.
+ """
+ with tf.name_scope(scope, 'FilterFieldValueEquals'):
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain the specified field')
+ filter_field = boxlist.get_field(field)
+ gather_index = tf.reshape(tf.where(tf.equal(filter_field, value)), [-1])
+ return gather(boxlist, gather_index)
+
+
+def filter_greater_than(boxlist, thresh, scope=None):
+ """Filter to keep only boxes with score exceeding a given threshold.
+
+ This op keeps the collection of boxes whose corresponding scores are
+ greater than the input threshold.
+
+ TODO(jonathanhuang): Change function name to filter_scores_greater_than
+
+ Args:
+ boxlist: BoxList holding N boxes. Must contain a 'scores' field
+ representing detection scores.
+ thresh: scalar threshold
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= N
+
+ Raises:
+ ValueError: if boxlist not a BoxList object or if it does not
+ have a scores field
+ """
+ with tf.name_scope(scope, 'FilterGreaterThan'):
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field('scores'):
+ raise ValueError('input boxlist must have \'scores\' field')
+ scores = boxlist.get_field('scores')
+ if len(scores.shape.as_list()) > 2:
+ raise ValueError('Scores should have rank 1 or 2')
+ if len(scores.shape.as_list()) == 2 and scores.shape.as_list()[1] != 1:
+ raise ValueError('Scores should have rank 1 or have shape '
+ 'consistent with [None, 1]')
+ high_score_indices = tf.cast(tf.reshape(
+ tf.where(tf.greater(scores, thresh)),
+ [-1]), tf.int32)
+ return gather(boxlist, high_score_indices)
+
+
+def non_max_suppression(boxlist, thresh, max_output_size, scope=None):
+ """Non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. Note that this only works for a single class ---
+ to apply NMS to multi-class predictions, use MultiClassNonMaxSuppression.
+
+ Args:
+ boxlist: BoxList holding N boxes. Must contain a 'scores' field
+ representing detection scores.
+ thresh: scalar threshold
+ max_output_size: maximum number of retained boxes
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= max_output_size
+ Raises:
+ ValueError: if thresh is not in [0, 1]
+ """
+ with tf.name_scope(scope, 'NonMaxSuppression'):
+ if not 0 <= thresh <= 1.0:
+ raise ValueError('thresh must be between 0 and 1')
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field('scores'):
+ raise ValueError('input boxlist must have \'scores\' field')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist.get(), boxlist.get_field('scores'),
+ max_output_size, iou_threshold=thresh)
+ return gather(boxlist, selected_indices)
+
+
+def _copy_extra_fields(boxlist_to_copy_to, boxlist_to_copy_from):
+ """Copies the extra fields of boxlist_to_copy_from to boxlist_to_copy_to.
+
+ Args:
+ boxlist_to_copy_to: BoxList to which extra fields are copied.
+ boxlist_to_copy_from: BoxList from which fields are copied.
+
+ Returns:
+ boxlist_to_copy_to with extra fields.
+ """
+ for field in boxlist_to_copy_from.get_extra_fields():
+ boxlist_to_copy_to.add_field(field, boxlist_to_copy_from.get_field(field))
+ return boxlist_to_copy_to
+
+
+def to_normalized_coordinates(boxlist, height, width,
+ check_range=True, scope=None):
+ """Converts absolute box coordinates to normalized coordinates in [0, 1].
+
+ Usually one uses the dynamic shape of the image or conv-layer tensor:
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(images)[1],
+ tf.shape(images)[2]),
+
+ This function raises an assertion failed error at graph execution time when
+ the maximum coordinate is smaller than 1.01 (which means that coordinates are
+ already normalized). The value 1.01 is to deal with small rounding errors.
+
+ Args:
+ boxlist: BoxList with coordinates in terms of pixel-locations.
+ height: Maximum value for height of absolute box coordinates.
+ width: Maximum value for width of absolute box coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ scope: name scope.
+
+ Returns:
+ boxlist with normalized coordinates in [0, 1].
+ """
+ with tf.name_scope(scope, 'ToNormalizedCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ if check_range:
+ max_val = tf.reduce_max(boxlist.get())
+ max_assert = tf.Assert(tf.greater(max_val, 1.01),
+ ['max value is lower than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(boxlist, 1 / height, 1 / width)
+
+
+def to_absolute_coordinates(boxlist,
+ height,
+ width,
+ check_range=True,
+ maximum_normalized_coordinate=1.1,
+ scope=None):
+ """Converts normalized box coordinates to absolute pixel coordinates.
+
+ This function raises an assertion failed error when the maximum box coordinate
+ value is larger than maximum_normalized_coordinate (in which case coordinates
+ are already absolute).
+
+ Args:
+ boxlist: BoxList with coordinates in range [0, 1].
+ height: Maximum value for height of absolute box coordinates.
+ width: Maximum value for width of absolute box coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ maximum_normalized_coordinate: Maximum coordinate value to be considered
+ as normalized, default to 1.1.
+ scope: name scope.
+
+ Returns:
+ boxlist with absolute coordinates in terms of the image size.
+
+ """
+ with tf.name_scope(scope, 'ToAbsoluteCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ # Ensure range of input boxes is correct.
+ if check_range:
+ box_maximum = tf.reduce_max(boxlist.get())
+ max_assert = tf.Assert(
+ tf.greater_equal(maximum_normalized_coordinate, box_maximum),
+ ['maximum box coordinate value is larger '
+ 'than %f: ' % maximum_normalized_coordinate, box_maximum])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(boxlist, height, width)
+
+
+def refine_boxes_multi_class(pool_boxes,
+ num_classes,
+ nms_iou_thresh,
+ nms_max_detections,
+ voting_iou_thresh=0.5):
+ """Refines a pool of boxes using non max suppression and box voting.
+
+ Box refinement is done independently for each class.
+
+ Args:
+ pool_boxes: (BoxList) A collection of boxes to be refined. pool_boxes must
+ have a rank 1 'scores' field and a rank 1 'classes' field.
+ num_classes: (int scalar) Number of classes.
+ nms_iou_thresh: (float scalar) iou threshold for non max suppression (NMS).
+ nms_max_detections: (int scalar) maximum output size for NMS.
+ voting_iou_thresh: (float scalar) iou threshold for box voting.
+
+ Returns:
+ BoxList of refined boxes.
+
+ Raises:
+ ValueError: if
+ a) nms_iou_thresh or voting_iou_thresh is not in [0, 1].
+ b) pool_boxes is not a BoxList.
+ c) pool_boxes does not have a scores and classes field.
+ """
+ if not 0.0 <= nms_iou_thresh <= 1.0:
+ raise ValueError('nms_iou_thresh must be between 0 and 1')
+ if not 0.0 <= voting_iou_thresh <= 1.0:
+ raise ValueError('voting_iou_thresh must be between 0 and 1')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+ if not pool_boxes.has_field('classes'):
+ raise ValueError('pool_boxes must have a \'classes\' field')
+
+ refined_boxes = []
+ for i in range(num_classes):
+ boxes_class = filter_field_value_equals(pool_boxes, 'classes', i)
+ refined_boxes_class = refine_boxes(boxes_class, nms_iou_thresh,
+ nms_max_detections, voting_iou_thresh)
+ refined_boxes.append(refined_boxes_class)
+ return sort_by_field(concatenate(refined_boxes), 'scores')
+
+
+def refine_boxes(pool_boxes,
+ nms_iou_thresh,
+ nms_max_detections,
+ voting_iou_thresh=0.5):
+ """Refines a pool of boxes using non max suppression and box voting.
+
+ Args:
+ pool_boxes: (BoxList) A collection of boxes to be refined. pool_boxes must
+ have a rank 1 'scores' field.
+ nms_iou_thresh: (float scalar) iou threshold for non max suppression (NMS).
+ nms_max_detections: (int scalar) maximum output size for NMS.
+ voting_iou_thresh: (float scalar) iou threshold for box voting.
+
+ Returns:
+ BoxList of refined boxes.
+
+ Raises:
+ ValueError: if
+ a) nms_iou_thresh or voting_iou_thresh is not in [0, 1].
+ b) pool_boxes is not a BoxList.
+ c) pool_boxes does not have a scores field.
+ """
+ if not 0.0 <= nms_iou_thresh <= 1.0:
+ raise ValueError('nms_iou_thresh must be between 0 and 1')
+ if not 0.0 <= voting_iou_thresh <= 1.0:
+ raise ValueError('voting_iou_thresh must be between 0 and 1')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+
+ nms_boxes = non_max_suppression(
+ pool_boxes, nms_iou_thresh, nms_max_detections)
+ return box_voting(nms_boxes, pool_boxes, voting_iou_thresh)
+
+
+def box_voting(selected_boxes, pool_boxes, iou_thresh=0.5):
+ """Performs box voting as described in S. Gidaris and N. Komodakis, ICCV 2015.
+
+ Performs box voting as described in 'Object detection via a multi-region &
+ semantic segmentation-aware CNN model', Gidaris and Komodakis, ICCV 2015. For
+ each box 'B' in selected_boxes, we find the set 'S' of boxes in pool_boxes
+ with iou overlap >= iou_thresh. The location of B is set to the weighted
+ average location of boxes in S (scores are used for weighting). And the score
+ of B is set to the average score of boxes in S.
+
+ Args:
+ selected_boxes: BoxList containing a subset of boxes in pool_boxes. These
+ boxes are usually selected from pool_boxes using non max suppression.
+ pool_boxes: BoxList containing a set of (possibly redundant) boxes.
+ iou_thresh: (float scalar) iou threshold for matching boxes in
+ selected_boxes and pool_boxes.
+
+ Returns:
+ BoxList containing averaged locations and scores for each box in
+ selected_boxes.
+
+ Raises:
+ ValueError: if
+ a) selected_boxes or pool_boxes is not a BoxList.
+ b) if iou_thresh is not in [0, 1].
+ c) pool_boxes does not have a scores field.
+ """
+ if not 0.0 <= iou_thresh <= 1.0:
+ raise ValueError('iou_thresh must be between 0 and 1')
+ if not isinstance(selected_boxes, box_list.BoxList):
+ raise ValueError('selected_boxes must be a BoxList')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+
+ iou_ = iou(selected_boxes, pool_boxes)
+ match_indicator = tf.cast(tf.greater(iou_, iou_thresh), dtype=tf.float32)
+ num_matches = tf.reduce_sum(match_indicator, 1)
+ # TODO(kbanoop): Handle the case where some boxes in selected_boxes do not
+ # match to any boxes in pool_boxes. For such boxes without any matches, we
+ # should return the original boxes without voting.
+ match_assert = tf.Assert(
+ tf.reduce_all(tf.greater(num_matches, 0)),
+ ['Each box in selected_boxes must match with at least one box '
+ 'in pool_boxes.'])
+
+ scores = tf.expand_dims(pool_boxes.get_field('scores'), 1)
+ scores_assert = tf.Assert(
+ tf.reduce_all(tf.greater_equal(scores, 0)),
+ ['Scores must be non negative.'])
+
+ with tf.control_dependencies([scores_assert, match_assert]):
+ sum_scores = tf.matmul(match_indicator, scores)
+ averaged_scores = tf.reshape(sum_scores, [-1]) / num_matches
+
+ box_locations = tf.matmul(match_indicator,
+ pool_boxes.get() * scores) / sum_scores
+ averaged_boxes = box_list.BoxList(box_locations)
+ _copy_extra_fields(averaged_boxes, selected_boxes)
+ averaged_boxes.add_field('scores', averaged_scores)
+ return averaged_boxes
+
+
+def pad_or_clip_box_list(boxlist, num_boxes, scope=None):
+ """Pads or clips all fields of a BoxList.
+
+ Args:
+ boxlist: A BoxList with arbitrary of number of boxes.
+ num_boxes: First num_boxes in boxlist are kept.
+ The fields are zero-padded if num_boxes is bigger than the
+ actual number of boxes.
+ scope: name scope.
+
+ Returns:
+ BoxList with all fields padded or clipped.
+ """
+ with tf.name_scope(scope, 'PadOrClipBoxList'):
+ subboxlist = box_list.BoxList(shape_utils.pad_or_clip_tensor(
+ boxlist.get(), num_boxes))
+ for field in boxlist.get_extra_fields():
+ subfield = shape_utils.pad_or_clip_tensor(
+ boxlist.get_field(field), num_boxes)
+ subboxlist.add_field(field, subfield)
+ return subboxlist
+
+
+def select_random_box(boxlist,
+ default_box=None,
+ seed=None,
+ scope=None):
+ """Selects a random bounding box from a `BoxList`.
+
+ Args:
+ boxlist: A BoxList.
+ default_box: A [1, 4] float32 tensor. If no boxes are present in `boxlist`,
+ this default box will be returned. If None, will use a default box of
+ [[-1., -1., -1., -1.]].
+ seed: Random seed.
+ scope: Name scope.
+
+ Returns:
+ bbox: A [1, 4] tensor with a random bounding box.
+ valid: A bool tensor indicating whether a valid bounding box is returned
+ (True) or whether the default box is returned (False).
+ """
+ with tf.name_scope(scope, 'SelectRandomBox'):
+ bboxes = boxlist.get()
+ combined_shape = shape_utils.combined_static_and_dynamic_shape(bboxes)
+ number_of_boxes = combined_shape[0]
+ default_box = default_box or tf.constant([[-1., -1., -1., -1.]])
+
+ def select_box():
+ random_index = tf.random_uniform([],
+ maxval=number_of_boxes,
+ dtype=tf.int32,
+ seed=seed)
+ return tf.expand_dims(bboxes[random_index], axis=0), tf.constant(True)
+
+ return tf.cond(
+ tf.greater_equal(number_of_boxes, 1),
+ true_fn=select_box,
+ false_fn=lambda: (default_box, tf.constant(False)))
+
+
+def get_minimal_coverage_box(boxlist,
+ default_box=None,
+ scope=None):
+ """Creates a single bounding box which covers all boxes in the boxlist.
+
+ Args:
+ boxlist: A Boxlist.
+ default_box: A [1, 4] float32 tensor. If no boxes are present in `boxlist`,
+ this default box will be returned. If None, will use a default box of
+ [[0., 0., 1., 1.]].
+ scope: Name scope.
+
+ Returns:
+ A [1, 4] float32 tensor with a bounding box that tightly covers all the
+ boxes in the box list. If the boxlist does not contain any boxes, the
+ default box is returned.
+ """
+ with tf.name_scope(scope, 'CreateCoverageBox'):
+ num_boxes = boxlist.num_boxes()
+
+ def coverage_box(bboxes):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=bboxes, num_or_size_splits=4, axis=1)
+ y_min_coverage = tf.reduce_min(y_min, axis=0)
+ x_min_coverage = tf.reduce_min(x_min, axis=0)
+ y_max_coverage = tf.reduce_max(y_max, axis=0)
+ x_max_coverage = tf.reduce_max(x_max, axis=0)
+ return tf.stack(
+ [y_min_coverage, x_min_coverage, y_max_coverage, x_max_coverage],
+ axis=1)
+
+ default_box = default_box or tf.constant([[0., 0., 1., 1.]])
+ return tf.cond(
+ tf.greater_equal(num_boxes, 1),
+ true_fn=lambda: coverage_box(boxlist.get()),
+ false_fn=lambda: default_box)
+
+
+def sample_boxes_by_jittering(boxlist,
+ num_boxes_to_sample,
+ stddev=0.1,
+ scope=None):
+ """Samples num_boxes_to_sample boxes by jittering around boxlist boxes.
+
+ It is possible that this function might generate boxes with size 0. The larger
+ the stddev, this is more probable. For a small stddev of 0.1 this probability
+ is very small.
+
+ Args:
+ boxlist: A boxlist containing N boxes in normalized coordinates.
+ num_boxes_to_sample: A positive integer containing the number of boxes to
+ sample.
+ stddev: Standard deviation. This is used to draw random offsets for the
+ box corners from a normal distribution. The offset is multiplied by the
+ box size so will be larger in terms of pixels for larger boxes.
+ scope: Name scope.
+
+ Returns:
+ sampled_boxlist: A boxlist containing num_boxes_to_sample boxes in
+ normalized coordinates.
+ """
+ with tf.name_scope(scope, 'SampleBoxesByJittering'):
+ num_boxes = boxlist.num_boxes()
+ box_indices = tf.random_uniform(
+ [num_boxes_to_sample],
+ minval=0,
+ maxval=num_boxes,
+ dtype=tf.int32)
+ sampled_boxes = tf.gather(boxlist.get(), box_indices)
+ sampled_boxes_height = sampled_boxes[:, 2] - sampled_boxes[:, 0]
+ sampled_boxes_width = sampled_boxes[:, 3] - sampled_boxes[:, 1]
+ rand_miny_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_minx_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_maxy_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_maxx_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ miny = rand_miny_gaussian * sampled_boxes_height + sampled_boxes[:, 0]
+ minx = rand_minx_gaussian * sampled_boxes_width + sampled_boxes[:, 1]
+ maxy = rand_maxy_gaussian * sampled_boxes_height + sampled_boxes[:, 2]
+ maxx = rand_maxx_gaussian * sampled_boxes_width + sampled_boxes[:, 3]
+ maxy = tf.maximum(miny, maxy)
+ maxx = tf.maximum(minx, maxx)
+ sampled_boxes = tf.stack([miny, minx, maxy, maxx], axis=1)
+ sampled_boxes = tf.maximum(tf.minimum(sampled_boxes, 1.0), 0.0)
+ return box_list.BoxList(sampled_boxes)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops_test.py b/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops_test.py
new file mode 100644
index 00000000..efe29913
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_list_ops_test.py
@@ -0,0 +1,1108 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_list_ops."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.utils import test_case
+
+
+class BoxListOpsTest(test_case.TestCase):
+ """Tests for common bounding box operations."""
+
+ def test_area(self):
+ corners = tf.constant([[0.0, 0.0, 10.0, 20.0], [1.0, 2.0, 3.0, 4.0]])
+ exp_output = [200.0, 4.0]
+ boxes = box_list.BoxList(corners)
+ areas = box_list_ops.area(boxes)
+ with self.test_session() as sess:
+ areas_output = sess.run(areas)
+ self.assertAllClose(areas_output, exp_output)
+
+ def test_height_width(self):
+ corners = tf.constant([[0.0, 0.0, 10.0, 20.0], [1.0, 2.0, 3.0, 4.0]])
+ exp_output_heights = [10., 2.]
+ exp_output_widths = [20., 2.]
+ boxes = box_list.BoxList(corners)
+ heights, widths = box_list_ops.height_width(boxes)
+ with self.test_session() as sess:
+ output_heights, output_widths = sess.run([heights, widths])
+ self.assertAllClose(output_heights, exp_output_heights)
+ self.assertAllClose(output_widths, exp_output_widths)
+
+ def test_scale(self):
+ corners = tf.constant([[0, 0, 100, 200], [50, 120, 100, 140]],
+ dtype=tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2]]))
+
+ y_scale = tf.constant(1.0/100)
+ x_scale = tf.constant(1.0/200)
+ scaled_boxes = box_list_ops.scale(boxes, y_scale, x_scale)
+ exp_output = [[0, 0, 1, 1], [0.5, 0.6, 1.0, 0.7]]
+ with self.test_session() as sess:
+ scaled_corners_out = sess.run(scaled_boxes.get())
+ self.assertAllClose(scaled_corners_out, exp_output)
+ extra_data_out = sess.run(scaled_boxes.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2]])
+
+ def test_clip_to_window_filter_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0],
+ [-10.0, -10.0, -9.0, -9.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0], [0.0, 0.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0], [0.0, 0.0, 9.0, 14.0],
+ [0.0, 0.0, 9.0, 14.0]]
+ pruned = box_list_ops.clip_to_window(
+ boxes, window, filter_nonoverlapping=True)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [5]])
+
+ def test_clip_to_window_without_filtering_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0],
+ [-10.0, -10.0, -9.0, -9.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0], [0.0, 0.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0], [0.0, 0.0, 9.0, 14.0],
+ [0.0, 0.0, 9.0, 14.0], [0.0, 0.0, 0.0, 0.0]]
+ pruned = box_list_ops.clip_to_window(
+ boxes, window, filter_nonoverlapping=False)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [5], [6]])
+
+ def test_prune_outside_window_filters_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-10.0, -10.0, -9.0, -9.0],
+ [-100.0, -100.0, 300.0, 600.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0]]
+ pruned, keep_indices = box_list_ops.prune_outside_window(boxes, window)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ keep_indices_out = sess.run(keep_indices)
+ self.assertAllEqual(keep_indices_out, [0, 2, 3])
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [3], [4]])
+
+ def test_prune_completely_outside_window(self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-10.0, -10.0, -9.0, -9.0],
+ [-100.0, -100.0, 300.0, 600.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0]]
+ pruned, keep_indices = box_list_ops.prune_completely_outside_window(boxes,
+ window)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ keep_indices_out = sess.run(keep_indices)
+ self.assertAllEqual(keep_indices_out, [0, 1, 2, 3, 5])
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [6]])
+
+ def test_prune_completely_outside_window_with_empty_boxlist(self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.zeros(shape=[0, 4], dtype=tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.zeros(shape=[0], dtype=tf.int32))
+ pruned, keep_indices = box_list_ops.prune_completely_outside_window(boxes,
+ window)
+ pruned_boxes = pruned.get()
+ extra = pruned.get_field('extra_data')
+
+ exp_pruned_boxes = np.zeros(shape=[0, 4], dtype=np.float32)
+ exp_extra = np.zeros(shape=[0], dtype=np.int32)
+ with self.test_session() as sess:
+ pruned_boxes_out, keep_indices_out, extra_out = sess.run(
+ [pruned_boxes, keep_indices, extra])
+ self.assertAllClose(exp_pruned_boxes, pruned_boxes_out)
+ self.assertAllEqual([], keep_indices_out)
+ self.assertAllEqual(exp_extra, extra_out)
+
+ def test_intersection(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0, 0.0, 6.0], [1.0, 0.0, 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ intersect = box_list_ops.intersection(boxes1, boxes2)
+ with self.test_session() as sess:
+ intersect_output = sess.run(intersect)
+ self.assertAllClose(intersect_output, exp_output)
+
+ def test_matched_intersection(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
+ exp_output = [2.0, 0.0]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ intersect = box_list_ops.matched_intersection(boxes1, boxes2)
+ with self.test_session() as sess:
+ intersect_output = sess.run(intersect)
+ self.assertAllClose(intersect_output, exp_output)
+
+ def test_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0 / 16.0, 0, 6.0 / 400.0], [1.0 / 16.0, 0.0, 5.0 / 400.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou = box_list_ops.iou(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_matched_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
+ exp_output = [2.0 / 16.0, 0]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou = box_list_ops.matched_iou(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_iouworks_on_empty_inputs(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ boxes_empty = box_list.BoxList(tf.zeros((0, 4)))
+ iou_empty_1 = box_list_ops.iou(boxes1, boxes_empty)
+ iou_empty_2 = box_list_ops.iou(boxes_empty, boxes2)
+ iou_empty_3 = box_list_ops.iou(boxes_empty, boxes_empty)
+ with self.test_session() as sess:
+ iou_output_1, iou_output_2, iou_output_3 = sess.run(
+ [iou_empty_1, iou_empty_2, iou_empty_3])
+ self.assertAllEqual(iou_output_1.shape, (2, 0))
+ self.assertAllEqual(iou_output_2.shape, (0, 3))
+ self.assertAllEqual(iou_output_3.shape, (0, 0))
+
+ def test_ioa(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output_1 = [[2.0 / 12.0, 0, 6.0 / 400.0],
+ [1.0 / 12.0, 0.0, 5.0 / 400.0]]
+ exp_output_2 = [[2.0 / 6.0, 1.0 / 5.0],
+ [0, 0],
+ [6.0 / 6.0, 5.0 / 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ ioa_1 = box_list_ops.ioa(boxes1, boxes2)
+ ioa_2 = box_list_ops.ioa(boxes2, boxes1)
+ with self.test_session() as sess:
+ ioa_output_1, ioa_output_2 = sess.run([ioa_1, ioa_2])
+ self.assertAllClose(ioa_output_1, exp_output_1)
+ self.assertAllClose(ioa_output_2, exp_output_2)
+
+ def test_prune_non_overlapping_boxes(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ minoverlap = 0.5
+
+ exp_output_1 = boxes1
+ exp_output_2 = box_list.BoxList(tf.constant(0.0, shape=[0, 4]))
+ output_1, keep_indices_1 = box_list_ops.prune_non_overlapping_boxes(
+ boxes1, boxes2, min_overlap=minoverlap)
+ output_2, keep_indices_2 = box_list_ops.prune_non_overlapping_boxes(
+ boxes2, boxes1, min_overlap=minoverlap)
+ with self.test_session() as sess:
+ (output_1_, keep_indices_1_, output_2_, keep_indices_2_, exp_output_1_,
+ exp_output_2_) = sess.run(
+ [output_1.get(), keep_indices_1,
+ output_2.get(), keep_indices_2,
+ exp_output_1.get(), exp_output_2.get()])
+ self.assertAllClose(output_1_, exp_output_1_)
+ self.assertAllClose(output_2_, exp_output_2_)
+ self.assertAllEqual(keep_indices_1_, [0, 1])
+ self.assertAllEqual(keep_indices_2_, [])
+
+ def test_prune_small_boxes(self):
+ boxes = tf.constant([[4.0, 3.0, 7.0, 5.0],
+ [5.0, 6.0, 10.0, 7.0],
+ [3.0, 4.0, 6.0, 8.0],
+ [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_boxes = [[3.0, 4.0, 6.0, 8.0],
+ [0.0, 0.0, 20.0, 20.0]]
+ boxes = box_list.BoxList(boxes)
+ pruned_boxes = box_list_ops.prune_small_boxes(boxes, 3)
+ with self.test_session() as sess:
+ pruned_boxes = sess.run(pruned_boxes.get())
+ self.assertAllEqual(pruned_boxes, exp_boxes)
+
+ def test_prune_small_boxes_prunes_boxes_with_negative_side(self):
+ boxes = tf.constant([[4.0, 3.0, 7.0, 5.0],
+ [5.0, 6.0, 10.0, 7.0],
+ [3.0, 4.0, 6.0, 8.0],
+ [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0],
+ [2.0, 3.0, 1.5, 7.0], # negative height
+ [2.0, 3.0, 5.0, 1.7]]) # negative width
+ exp_boxes = [[3.0, 4.0, 6.0, 8.0],
+ [0.0, 0.0, 20.0, 20.0]]
+ boxes = box_list.BoxList(boxes)
+ pruned_boxes = box_list_ops.prune_small_boxes(boxes, 3)
+ with self.test_session() as sess:
+ pruned_boxes = sess.run(pruned_boxes.get())
+ self.assertAllEqual(pruned_boxes, exp_boxes)
+
+ def test_change_coordinate_frame(self):
+ corners = tf.constant([[0.25, 0.5, 0.75, 0.75], [0.5, 0.0, 1.0, 1.0]])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+ boxes = box_list.BoxList(corners)
+
+ expected_corners = tf.constant([[0, 0.5, 1.0, 1.0], [0.5, -0.5, 1.5, 1.5]])
+ expected_boxes = box_list.BoxList(expected_corners)
+ output = box_list_ops.change_coordinate_frame(boxes, window)
+
+ with self.test_session() as sess:
+ output_, expected_boxes_ = sess.run([output.get(), expected_boxes.get()])
+ self.assertAllClose(output_, expected_boxes_)
+
+ def test_ioaworks_on_empty_inputs(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ boxes_empty = box_list.BoxList(tf.zeros((0, 4)))
+ ioa_empty_1 = box_list_ops.ioa(boxes1, boxes_empty)
+ ioa_empty_2 = box_list_ops.ioa(boxes_empty, boxes2)
+ ioa_empty_3 = box_list_ops.ioa(boxes_empty, boxes_empty)
+ with self.test_session() as sess:
+ ioa_output_1, ioa_output_2, ioa_output_3 = sess.run(
+ [ioa_empty_1, ioa_empty_2, ioa_empty_3])
+ self.assertAllEqual(ioa_output_1.shape, (2, 0))
+ self.assertAllEqual(ioa_output_2.shape, (0, 3))
+ self.assertAllEqual(ioa_output_3.shape, (0, 0))
+
+ def test_pairwise_distances(self):
+ corners1 = tf.constant([[0.0, 0.0, 0.0, 0.0],
+ [1.0, 1.0, 0.0, 2.0]])
+ corners2 = tf.constant([[3.0, 4.0, 1.0, 0.0],
+ [-4.0, 0.0, 0.0, 3.0],
+ [0.0, 0.0, 0.0, 0.0]])
+ exp_output = [[26, 25, 0], [18, 27, 6]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ dist_matrix = box_list_ops.sq_dist(boxes1, boxes2)
+ with self.test_session() as sess:
+ dist_output = sess.run(dist_matrix)
+ self.assertAllClose(dist_output, exp_output)
+
+ def test_boolean_mask(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indicator = tf.constant([True, False, True, False, True], tf.bool)
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ boxes = box_list.BoxList(corners)
+ subset = box_list_ops.boolean_mask(boxes, indicator)
+ with self.test_session() as sess:
+ subset_output = sess.run(subset.get())
+ self.assertAllClose(subset_output, expected_subset)
+
+ def test_static_boolean_mask_with_field(self):
+
+ def graph_fn(corners, weights, indicator):
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.boolean_mask(
+ boxes,
+ indicator, ['weights'],
+ use_static_shapes=True,
+ indicator_sum=3)
+ return (subset.get_field('boxes'), subset.get_field('weights'))
+
+ corners = np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]],
+ dtype=np.float32)
+ indicator = np.array([True, False, True, False, True], dtype=np.bool)
+ weights = np.array([[.1], [.3], [.5], [.7], [.9]], dtype=np.float32)
+ result_boxes, result_weights = self.execute(graph_fn,
+ [corners, weights, indicator])
+ expected_boxes = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ self.assertAllClose(result_boxes, expected_boxes)
+ self.assertAllClose(result_weights, expected_weights)
+
+ def test_dynamic_boolean_mask_with_field(self):
+ corners = tf.placeholder(tf.float32, [None, 4])
+ indicator = tf.placeholder(tf.bool, [None])
+ weights = tf.placeholder(tf.float32, [None, 1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.boolean_mask(boxes, indicator, ['weights'])
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run(
+ [subset.get(), subset.get_field('weights')],
+ feed_dict={
+ corners:
+ np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]]),
+ indicator:
+ np.array([True, False, True, False, True]).astype(np.bool),
+ weights:
+ np.array([[.1], [.3], [.5], [.7], [.9]])
+ })
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_gather(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indices = tf.constant([0, 2, 4], tf.int32)
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ boxes = box_list.BoxList(corners)
+ subset = box_list_ops.gather(boxes, indices)
+ with self.test_session() as sess:
+ subset_output = sess.run(subset.get())
+ self.assertAllClose(subset_output, expected_subset)
+
+ def test_static_gather_with_field(self):
+
+ def graph_fn(corners, weights, indices):
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(
+ boxes, indices, ['weights'], use_static_shapes=True)
+ return (subset.get_field('boxes'), subset.get_field('weights'))
+
+ corners = np.array([4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0],
+ 4 * [4.0]], dtype=np.float32)
+ weights = np.array([[.1], [.3], [.5], [.7], [.9]], dtype=np.float32)
+ indices = np.array([0, 2, 4], dtype=np.int32)
+
+ result_boxes, result_weights = self.execute(graph_fn,
+ [corners, weights, indices])
+ expected_boxes = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+ self.assertAllClose(result_boxes, expected_boxes)
+ self.assertAllClose(result_weights, expected_weights)
+
+ def test_dynamic_gather_with_field(self):
+ corners = tf.placeholder(tf.float32, [None, 4])
+ indices = tf.placeholder(tf.int32, [None])
+ weights = tf.placeholder(tf.float32, [None, 1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(boxes, indices, ['weights'],
+ use_static_shapes=True)
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run(
+ [subset.get(), subset.get_field('weights')],
+ feed_dict={
+ corners:
+ np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]]),
+ indices:
+ np.array([0, 2, 4]).astype(np.int32),
+ weights:
+ np.array([[.1], [.3], [.5], [.7], [.9]])
+ })
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_gather_with_invalid_field(self):
+ corners = tf.constant([4 * [0.0], 4 * [1.0]])
+ indices = tf.constant([0, 1], tf.int32)
+ weights = tf.constant([[.1], [.3]], tf.float32)
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ with self.assertRaises(ValueError):
+ box_list_ops.gather(boxes, indices, ['foo', 'bar'])
+
+ def test_gather_with_invalid_inputs(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indices_float32 = tf.constant([0, 2, 4], tf.float32)
+ boxes = box_list.BoxList(corners)
+ with self.assertRaises(ValueError):
+ _ = box_list_ops.gather(boxes, indices_float32)
+ indices_2d = tf.constant([[0, 2, 4]], tf.int32)
+ boxes = box_list.BoxList(corners)
+ with self.assertRaises(ValueError):
+ _ = box_list_ops.gather(boxes, indices_2d)
+
+ def test_gather_with_dynamic_indexing(self):
+ corners = tf.constant([4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]
+ ])
+ weights = tf.constant([.5, .3, .7, .1, .9], tf.float32)
+ indices = tf.reshape(tf.where(tf.greater(weights, 0.4)), [-1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [.5, .7, .9]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(boxes, indices, ['weights'])
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run([subset.get(), subset.get_field(
+ 'weights')])
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_sort_by_field_ascending_order(self):
+ exp_corners = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]]
+ exp_scores = [.95, .9, .75, .6, .5, .3]
+ exp_weights = [.2, .45, .6, .75, .8, .92]
+ shuffle = [2, 4, 0, 5, 1, 3]
+ corners = tf.constant([exp_corners[i] for i in shuffle], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(
+ [exp_scores[i] for i in shuffle], tf.float32))
+ boxes.add_field('weights', tf.constant(
+ [exp_weights[i] for i in shuffle], tf.float32))
+ sort_by_weight = box_list_ops.sort_by_field(
+ boxes,
+ 'weights',
+ order=box_list_ops.SortOrder.ascend)
+ with self.test_session() as sess:
+ corners_out, scores_out, weights_out = sess.run([
+ sort_by_weight.get(),
+ sort_by_weight.get_field('scores'),
+ sort_by_weight.get_field('weights')])
+ self.assertAllClose(corners_out, exp_corners)
+ self.assertAllClose(scores_out, exp_scores)
+ self.assertAllClose(weights_out, exp_weights)
+
+ def test_sort_by_field_descending_order(self):
+ exp_corners = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]]
+ exp_scores = [.95, .9, .75, .6, .5, .3]
+ exp_weights = [.2, .45, .6, .75, .8, .92]
+ shuffle = [2, 4, 0, 5, 1, 3]
+
+ corners = tf.constant([exp_corners[i] for i in shuffle], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(
+ [exp_scores[i] for i in shuffle], tf.float32))
+ boxes.add_field('weights', tf.constant(
+ [exp_weights[i] for i in shuffle], tf.float32))
+
+ sort_by_score = box_list_ops.sort_by_field(boxes, 'scores')
+ with self.test_session() as sess:
+ corners_out, scores_out, weights_out = sess.run([sort_by_score.get(
+ ), sort_by_score.get_field('scores'), sort_by_score.get_field('weights')])
+ self.assertAllClose(corners_out, exp_corners)
+ self.assertAllClose(scores_out, exp_scores)
+ self.assertAllClose(weights_out, exp_weights)
+
+ def test_sort_by_field_invalid_inputs(self):
+ corners = tf.constant([4 * [0.0], 4 * [0.5], 4 * [1.0], 4 * [2.0], 4 *
+ [3.0], 4 * [4.0]])
+ misc = tf.constant([[.95, .9], [.5, .3]], tf.float32)
+ weights = tf.constant([.1, .2], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('misc', misc)
+ boxes.add_field('weights', weights)
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'area')
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'misc')
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'weights')
+
+ def test_visualize_boxes_in_image(self):
+ image = tf.zeros((6, 4, 3))
+ corners = tf.constant([[0, 0, 5, 3],
+ [0, 0, 3, 2]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ image_and_boxes = box_list_ops.visualize_boxes_in_image(image, boxes)
+ image_and_boxes_bw = tf.cast(
+ tf.greater(tf.reduce_sum(image_and_boxes, 2), 0.0), dtype=tf.float32)
+ exp_result = [[1, 1, 1, 0],
+ [1, 1, 1, 0],
+ [1, 1, 1, 0],
+ [1, 0, 1, 0],
+ [1, 1, 1, 0],
+ [0, 0, 0, 0]]
+ with self.test_session() as sess:
+ output = sess.run(image_and_boxes_bw)
+ self.assertAllEqual(output.astype(int), exp_result)
+
+ def test_filter_field_value_equals(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('classes', tf.constant([1, 2, 1, 2, 2, 1]))
+ exp_output1 = [[0, 0, 1, 1], [0, -0.1, 1, 0.9], [0, 100, 1, 101]]
+ exp_output2 = [[0, 0.1, 1, 1.1], [0, 10, 1, 11], [0, 10.1, 1, 11.1]]
+
+ filtered_boxes1 = box_list_ops.filter_field_value_equals(
+ boxes, 'classes', 1)
+ filtered_boxes2 = box_list_ops.filter_field_value_equals(
+ boxes, 'classes', 2)
+ with self.test_session() as sess:
+ filtered_output1, filtered_output2 = sess.run([filtered_boxes1.get(),
+ filtered_boxes2.get()])
+ self.assertAllClose(filtered_output1, exp_output1)
+ self.assertAllClose(filtered_output2, exp_output2)
+
+ def test_filter_greater_than(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.1, .75, .9, .5, .5, .8]))
+ thresh = .6
+ exp_output = [[0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9], [0, 100, 1, 101]]
+
+ filtered_boxes = box_list_ops.filter_greater_than(boxes, thresh)
+ with self.test_session() as sess:
+ filtered_output = sess.run(filtered_boxes.get())
+ self.assertAllClose(filtered_output, exp_output)
+
+ def test_clip_box_list(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8], [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 0, 1, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.65, 0.3, 0.2]))
+ num_boxes = 2
+ clipped_boxlist = box_list_ops.pad_or_clip_box_list(boxlist, num_boxes)
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 0]
+ expected_scores = [0.75, 0.65]
+ with self.test_session() as sess:
+ boxes_out, classes_out, scores_out = sess.run(
+ [clipped_boxlist.get(), clipped_boxlist.get_field('classes'),
+ clipped_boxlist.get_field('scores')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllEqual(expected_classes, classes_out)
+ self.assertAllClose(expected_scores, scores_out)
+
+ def test_pad_box_list(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ num_boxes = 4
+ padded_boxlist = box_list_ops.pad_or_clip_box_list(boxlist, num_boxes)
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0, 0, 0, 0], [0, 0, 0, 0]]
+ expected_classes = [0, 1, 0, 0]
+ expected_scores = [0.75, 0.2, 0, 0]
+ with self.test_session() as sess:
+ boxes_out, classes_out, scores_out = sess.run(
+ [padded_boxlist.get(), padded_boxlist.get_field('classes'),
+ padded_boxlist.get_field('scores')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllEqual(expected_classes, classes_out)
+ self.assertAllClose(expected_scores, scores_out)
+
+ def test_select_random_box(self):
+ boxes = [[0., 0., 1., 1.],
+ [0., 1., 2., 3.],
+ [0., 2., 3., 4.]]
+
+ corners = tf.constant(boxes, dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ random_bbox, valid = box_list_ops.select_random_box(boxlist)
+ with self.test_session() as sess:
+ random_bbox_out, valid_out = sess.run([random_bbox, valid])
+
+ norm_small = any(
+ [np.linalg.norm(random_bbox_out - box) < 1e-6 for box in boxes])
+
+ self.assertTrue(norm_small)
+ self.assertTrue(valid_out)
+
+ def test_select_random_box_with_empty_boxlist(self):
+ corners = tf.constant([], shape=[0, 4], dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ random_bbox, valid = box_list_ops.select_random_box(boxlist)
+ with self.test_session() as sess:
+ random_bbox_out, valid_out = sess.run([random_bbox, valid])
+
+ expected_bbox_out = np.array([[-1., -1., -1., -1.]], dtype=np.float32)
+ self.assertAllEqual(expected_bbox_out, random_bbox_out)
+ self.assertFalse(valid_out)
+
+ def test_get_minimal_coverage_box(self):
+ boxes = [[0., 0., 1., 1.],
+ [-1., 1., 2., 3.],
+ [0., 2., 3., 4.]]
+
+ expected_coverage_box = [[-1., 0., 3., 4.]]
+
+ corners = tf.constant(boxes, dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ coverage_box = box_list_ops.get_minimal_coverage_box(boxlist)
+ with self.test_session() as sess:
+ coverage_box_out = sess.run(coverage_box)
+
+ self.assertAllClose(expected_coverage_box, coverage_box_out)
+
+ def test_get_minimal_coverage_box_with_empty_boxlist(self):
+ corners = tf.constant([], shape=[0, 4], dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ coverage_box = box_list_ops.get_minimal_coverage_box(boxlist)
+ with self.test_session() as sess:
+ coverage_box_out = sess.run(coverage_box)
+
+ self.assertAllClose([[0.0, 0.0, 1.0, 1.0]], coverage_box_out)
+
+
+class ConcatenateTest(tf.test.TestCase):
+
+ def test_invalid_input_box_list_list(self):
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate(None)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([])
+ with self.assertRaises(ValueError):
+ corners = tf.constant([[0, 0, 0, 0]], tf.float32)
+ boxlist = box_list.BoxList(corners)
+ box_list_ops.concatenate([boxlist, 2])
+
+ def test_concatenate_with_missing_fields(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8]], tf.float32)
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([boxlist1, boxlist2])
+
+ def test_concatenate_with_incompatible_field_shapes(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8]], tf.float32)
+ scores2 = tf.constant([[1.0, 1.0], [2.1, 3.2]])
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ boxlist2.add_field('scores', scores2)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([boxlist1, boxlist2])
+
+ def test_concatenate_is_correct(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8], [1, 0, 5, 10]],
+ tf.float32)
+ scores2 = tf.constant([1.0, 2.1, 5.6])
+
+ exp_corners = [[0, 0, 0, 0],
+ [1, 2, 3, 4],
+ [0, 3, 1, 6],
+ [2, 4, 3, 8],
+ [1, 0, 5, 10]]
+ exp_scores = [1.0, 2.1, 1.0, 2.1, 5.6]
+
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ boxlist2.add_field('scores', scores2)
+ result = box_list_ops.concatenate([boxlist1, boxlist2])
+ with self.test_session() as sess:
+ corners_output, scores_output = sess.run(
+ [result.get(), result.get_field('scores')])
+ self.assertAllClose(corners_output, exp_corners)
+ self.assertAllClose(scores_output, exp_scores)
+
+
+class NonMaxSuppressionTest(tf.test.TestCase):
+
+ def test_select_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_at_most_two_boxes_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 2
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_at_most_thirty_boxes_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 30
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_single_box(self):
+ corners = tf.constant([[0, 0, 1, 1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_from_ten_identical_boxes(self):
+ corners = tf.constant(10 * [[0, 0, 1, 1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(10 * [.9]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_copy_extra_fields(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ tensor1 = np.array([[1], [4]])
+ tensor2 = np.array([[1, 1], [2, 2]])
+ boxes.add_field('tensor1', tf.constant(tensor1))
+ boxes.add_field('tensor2', tf.constant(tensor2))
+ new_boxes = box_list.BoxList(tf.constant([[0, 0, 10, 10],
+ [1, 3, 5, 5]], tf.float32))
+ new_boxes = box_list_ops._copy_extra_fields(new_boxes, boxes)
+ with self.test_session() as sess:
+ self.assertAllClose(tensor1, sess.run(new_boxes.get_field('tensor1')))
+ self.assertAllClose(tensor2, sess.run(new_boxes.get_field('tensor2')))
+
+
+class CoordinatesConversionTest(tf.test.TestCase):
+
+ def test_to_normalized_coordinates(self):
+ coordinates = tf.constant([[0, 0, 100, 100],
+ [25, 25, 75, 75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ normalized_boxlist = box_list_ops.to_normalized_coordinates(
+ boxlist, tf.shape(img)[1], tf.shape(img)[2])
+ expected_boxes = [[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]]
+
+ with self.test_session() as sess:
+ normalized_boxes = sess.run(normalized_boxlist.get())
+ self.assertAllClose(normalized_boxes, expected_boxes)
+
+ def test_to_normalized_coordinates_already_normalized(self):
+ coordinates = tf.constant([[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ normalized_boxlist = box_list_ops.to_normalized_coordinates(
+ boxlist, tf.shape(img)[1], tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(normalized_boxlist.get())
+
+ def test_to_absolute_coordinates(self):
+ coordinates = tf.constant([[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ expected_boxes = [[0, 0, 100, 100],
+ [25, 25, 75, 75]]
+
+ with self.test_session() as sess:
+ absolute_boxes = sess.run(absolute_boxlist.get())
+ self.assertAllClose(absolute_boxes, expected_boxes)
+
+ def test_to_absolute_coordinates_already_abolute(self):
+ coordinates = tf.constant([[0, 0, 100, 100],
+ [25, 25, 75, 75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(absolute_boxlist.get())
+
+ def test_convert_to_normalized_and_back(self):
+ coordinates = np.random.uniform(size=(100, 4))
+ coordinates = np.round(np.sort(coordinates) * 200)
+ coordinates[:, 2:4] += 1
+ coordinates[99, :] = [0, 0, 201, 201]
+ img = tf.ones((128, 202, 202, 3))
+
+ boxlist = box_list.BoxList(tf.constant(coordinates, tf.float32))
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ out = sess.run(boxlist.get())
+ self.assertAllClose(out, coordinates)
+
+ def test_convert_to_absolute_and_back(self):
+ coordinates = np.random.uniform(size=(100, 4))
+ coordinates = np.sort(coordinates)
+ coordinates[99, :] = [0, 0, 1, 1]
+ img = tf.ones((128, 202, 202, 3))
+
+ boxlist = box_list.BoxList(tf.constant(coordinates, tf.float32))
+ boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ out = sess.run(boxlist.get())
+ self.assertAllClose(out, coordinates)
+
+ def test_to_absolute_coordinates_maximum_coordinate_check(self):
+ coordinates = tf.constant([[0, 0, 1.2, 1.2],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(
+ boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2],
+ maximum_normalized_coordinate=1.1)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(absolute_boxlist.get())
+
+
+class BoxRefinementTest(tf.test.TestCase):
+
+ def test_box_voting(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ candidates.add_field('ExtraField', tf.constant([1, 2]))
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8]]
+ expected_scores = [0.5, 0.3]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [averaged_boxes.get(), averaged_boxes.get_field('scores'),
+ averaged_boxes.get_field('ExtraField')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [1, 2])
+
+ def test_box_voting_fails_with_negative_scores(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool = box_list.BoxList(tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool.add_field('scores', tf.constant([-0.2]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('Scores must be non negative'):
+ sess.run([averaged_boxes.get()])
+
+ def test_box_voting_fails_when_unmatched(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool = box_list.BoxList(tf.constant([[0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('scores', tf.constant([0.2]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('Each box in selected_boxes must match '
+ 'with at least one box in pool_boxes.'):
+ sess.run([averaged_boxes.get()])
+
+ def test_refine_boxes(self):
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('ExtraField', tf.constant([1, 2, 3]))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3]))
+ refined_boxes = box_list_ops.refine_boxes(pool, 0.5, 10)
+
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8]]
+ expected_scores = [0.5, 0.3]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [refined_boxes.get(), refined_boxes.get_field('scores'),
+ refined_boxes.get_field('ExtraField')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [1, 3])
+
+ def test_refine_boxes_multi_class(self):
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8], [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ pool.add_field('classes', tf.constant([0, 0, 1, 1]))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3, 0.2]))
+ refined_boxes = box_list_ops.refine_boxes_multi_class(pool, 3, 0.5, 10)
+
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8],
+ [0.2, 0.2, 0.3, 0.3]]
+ expected_scores = [0.5, 0.3, 0.2]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [refined_boxes.get(), refined_boxes.get_field('scores'),
+ refined_boxes.get_field('classes')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [0, 1, 1])
+
+ def test_sample_boxes_by_jittering(self):
+ boxes = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4],
+ [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8],
+ [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ sampled_boxes = box_list_ops.sample_boxes_by_jittering(
+ boxlist=boxes, num_boxes_to_sample=10)
+ iou = box_list_ops.iou(boxes, sampled_boxes)
+ iou_max = tf.reduce_max(iou, axis=0)
+ with self.test_session() as sess:
+ (np_sampled_boxes, np_iou_max) = sess.run([sampled_boxes.get(), iou_max])
+ self.assertAllEqual(np_sampled_boxes.shape, [10, 4])
+ self.assertAllGreater(np_iou_max, 0.5)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_list_test.py b/Computer Vision/Plant_Disease_Detection_System/core/box_list_test.py
new file mode 100644
index 00000000..edc00ebb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_list_test.py
@@ -0,0 +1,134 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_list."""
+
+import tensorflow as tf
+
+from object_detection.core import box_list
+
+
+class BoxListTest(tf.test.TestCase):
+ """Tests for BoxList class."""
+
+ def test_num_boxes(self):
+ data = tf.constant([[0, 0, 1, 1], [1, 1, 2, 3], [3, 4, 5, 5]], tf.float32)
+ expected_num_boxes = 3
+
+ boxes = box_list.BoxList(data)
+ with self.test_session() as sess:
+ num_boxes_output = sess.run(boxes.num_boxes())
+ self.assertEquals(num_boxes_output, expected_num_boxes)
+
+ def test_get_correct_center_coordinates_and_sizes(self):
+ boxes = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(boxes))
+ centers_sizes = boxes.get_center_coordinates_and_sizes()
+ expected_centers_sizes = [[15, 0.35], [12.5, 0.25], [10, 0.3], [5, 0.3]]
+ with self.test_session() as sess:
+ centers_sizes_out = sess.run(centers_sizes)
+ self.assertAllClose(centers_sizes_out, expected_centers_sizes)
+
+ def test_create_box_list_with_dynamic_shape(self):
+ data = tf.constant([[0, 0, 1, 1], [1, 1, 2, 3], [3, 4, 5, 5]], tf.float32)
+ indices = tf.reshape(tf.where(tf.greater([1, 0, 1], 0)), [-1])
+ data = tf.gather(data, indices)
+ assert data.get_shape().as_list() == [None, 4]
+ expected_num_boxes = 2
+
+ boxes = box_list.BoxList(data)
+ with self.test_session() as sess:
+ num_boxes_output = sess.run(boxes.num_boxes())
+ self.assertEquals(num_boxes_output, expected_num_boxes)
+
+ def test_transpose_coordinates(self):
+ boxes = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(boxes))
+ boxes.transpose_coordinates()
+ expected_corners = [[10.0, 10.0, 15.0, 20.0], [0.1, 0.2, 0.4, 0.5]]
+ with self.test_session() as sess:
+ corners_out = sess.run(boxes.get())
+ self.assertAllClose(corners_out, expected_corners)
+
+ def test_box_list_invalid_inputs(self):
+ data0 = tf.constant([[[0, 0, 1, 1], [3, 4, 5, 5]]], tf.float32)
+ data1 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.float32)
+ data2 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.int32)
+
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data0)
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data1)
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data2)
+
+ def test_num_boxes_static(self):
+ box_corners = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+ self.assertEquals(boxes.num_boxes_static(), 2)
+ self.assertEquals(type(boxes.num_boxes_static()), int)
+
+ def test_num_boxes_static_for_uninferrable_shape(self):
+ placeholder = tf.placeholder(tf.float32, shape=[None, 4])
+ boxes = box_list.BoxList(placeholder)
+ self.assertEquals(boxes.num_boxes_static(), None)
+
+ def test_as_tensor_dict(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ tensor_dict = boxlist.as_tensor_dict()
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 1]
+ expected_scores = [0.75, 0.2]
+
+ with self.test_session() as sess:
+ tensor_dict_out = sess.run(tensor_dict)
+ self.assertAllEqual(3, len(tensor_dict_out))
+ self.assertAllClose(expected_boxes, tensor_dict_out['boxes'])
+ self.assertAllEqual(expected_classes, tensor_dict_out['classes'])
+ self.assertAllClose(expected_scores, tensor_dict_out['scores'])
+
+ def test_as_tensor_dict_with_features(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ tensor_dict = boxlist.as_tensor_dict(['boxes', 'classes', 'scores'])
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 1]
+ expected_scores = [0.75, 0.2]
+
+ with self.test_session() as sess:
+ tensor_dict_out = sess.run(tensor_dict)
+ self.assertAllEqual(3, len(tensor_dict_out))
+ self.assertAllClose(expected_boxes, tensor_dict_out['boxes'])
+ self.assertAllEqual(expected_classes, tensor_dict_out['classes'])
+ self.assertAllClose(expected_scores, tensor_dict_out['scores'])
+
+ def test_as_tensor_dict_missing_field(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ with self.assertRaises(ValueError):
+ boxlist.as_tensor_dict(['foo', 'bar'])
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/box_predictor.py b/Computer Vision/Plant_Disease_Detection_System/core/box_predictor.py
new file mode 100644
index 00000000..91a6647e
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/box_predictor.py
@@ -0,0 +1,227 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Box predictor for object detectors.
+
+Box predictors are classes that take a high level
+image feature map as input and produce two predictions,
+(1) a tensor encoding box locations, and
+(2) a tensor encoding classes for each box.
+
+These components are passed directly to loss functions
+in our detection models.
+
+These modules are separated from the main model since the same
+few box predictor architectures are shared across many models.
+"""
+from abc import abstractmethod
+import tensorflow as tf
+
+BOX_ENCODINGS = 'box_encodings'
+CLASS_PREDICTIONS_WITH_BACKGROUND = 'class_predictions_with_background'
+MASK_PREDICTIONS = 'mask_predictions'
+
+
+class BoxPredictor(object):
+ """BoxPredictor."""
+
+ def __init__(self, is_training, num_classes):
+ """Constructor.
+
+ Args:
+ is_training: Indicates whether the BoxPredictor is in training mode.
+ num_classes: number of classes. Note that num_classes *does not*
+ include the background category, so if groundtruth labels take values
+ in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
+ assigned classification targets can range from {0,... K}).
+ """
+ self._is_training = is_training
+ self._num_classes = num_classes
+
+ @property
+ def is_keras_model(self):
+ return False
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def predict(self, image_features, num_predictions_per_location,
+ scope=None, **params):
+ """Computes encoded object locations and corresponding confidences.
+
+ Takes a list of high level image feature maps as input and produces a list
+ of box encodings and a list of class scores where each element in the output
+ lists correspond to the feature maps in the input list.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ num_predictions_per_location: A list of integers representing the number
+ of box predictions to be made per spatial location for each feature map.
+ scope: Variable and Op scope name.
+ **params: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+
+ Raises:
+ ValueError: If length of `image_features` is not equal to length of
+ `num_predictions_per_location`.
+ """
+ if len(image_features) != len(num_predictions_per_location):
+ raise ValueError('image_feature and num_predictions_per_location must '
+ 'be of same length, found: {} vs {}'.
+ format(len(image_features),
+ len(num_predictions_per_location)))
+ if scope is not None:
+ with tf.variable_scope(scope):
+ return self._predict(image_features, num_predictions_per_location,
+ **params)
+ return self._predict(image_features, num_predictions_per_location,
+ **params)
+
+ # TODO(rathodv): num_predictions_per_location could be moved to constructor.
+ # This is currently only used by ConvolutionalBoxPredictor.
+ @abstractmethod
+ def _predict(self, image_features, num_predictions_per_location, **params):
+ """Implementations must override this method.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ num_predictions_per_location: A list of integers representing the number
+ of box predictions to be made per spatial location for each feature map.
+ **params: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ pass
+
+
+class KerasBoxPredictor(tf.keras.Model):
+ """Keras-based BoxPredictor."""
+
+ def __init__(self, is_training, num_classes, freeze_batchnorm,
+ inplace_batchnorm_update, name=None):
+ """Constructor.
+
+ Args:
+ is_training: Indicates whether the BoxPredictor is in training mode.
+ num_classes: number of classes. Note that num_classes *does not*
+ include the background category, so if groundtruth labels take values
+ in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
+ assigned classification targets can range from {0,... K}).
+ freeze_batchnorm: Whether to freeze batch norm parameters during
+ training or not. When training with a small batch size (e.g. 1), it is
+ desirable to freeze batch norm update and use pretrained batch norm
+ params.
+ inplace_batchnorm_update: Whether to update batch norm moving average
+ values inplace. When this is false train op must add a control
+ dependency on tf.graphkeys.UPDATE_OPS collection in order to update
+ batch norm statistics.
+ name: A string name scope to assign to the model. If `None`, Keras
+ will auto-generate one from the class name.
+ """
+ super(KerasBoxPredictor, self).__init__(name=name)
+
+ self._is_training = is_training
+ self._num_classes = num_classes
+ self._freeze_batchnorm = freeze_batchnorm
+ self._inplace_batchnorm_update = inplace_batchnorm_update
+
+ @property
+ def is_keras_model(self):
+ return True
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def call(self, image_features, **kwargs):
+ """Computes encoded object locations and corresponding confidences.
+
+ Takes a list of high level image feature maps as input and produces a list
+ of box encodings and a list of class scores where each element in the output
+ lists correspond to the feature maps in the input list.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ **kwargs: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ return self._predict(image_features, **kwargs)
+
+ @abstractmethod
+ def _predict(self, image_features, **kwargs):
+ """Implementations must override this method.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ **kwargs: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ raise NotImplementedError
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/class_agnostic_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/core/class_agnostic_nms_test.py
new file mode 100644
index 00000000..8a418b71
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/class_agnostic_nms_test.py
@@ -0,0 +1,155 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for google3.third_party.tensorflow_models.object_detection.core.class_agnostic_nms."""
+from absl.testing import parameterized
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.core import standard_fields as fields
+from object_detection.utils import test_case
+
+
+class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase,
+ parameterized.TestCase):
+
+ def test_class_agnostic_nms_select_with_shared_boxes(self):
+ boxes = tf.constant(
+ [[[0, 0, 1, 1]], [[0, 0.1, 1, 1.1]], [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]], [[0, 10.1, 1, 11.1]], [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]], [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05], [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01], [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_classes_per_detection = 1
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11], [0, 0, 1, 1], [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.class_agnostic_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_classes_per_detection,
+ max_output_size)
+
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)
+ ])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+
+ def test_class_agnostic_nms_select_with_per_class_boxes(self):
+ boxes = tf.constant(
+ [[[4, 5, 9, 10], [0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1], [4, 5, 9, 10]],
+ [[0, -0.1, 1, 0.9], [4, 5, 9, 10]],
+ [[0, 10, 1, 11], [4, 5, 9, 10]],
+ [[0, 10.1, 1, 11.1], [4, 5, 9, 10]],
+ [[0, 100, 1, 101], [4, 5, 9, 10]],
+ [[4, 5, 9, 10], [0, 1000, 1, 1002]],
+ [[4, 5, 9, 10], [0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.01, 0.9],
+ [.75, 0.05],
+ [.6, 0.01],
+ [.95, 0],
+ [.5, 0.01],
+ [.3, 0.01],
+ [.01, .85],
+ [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_classes_per_detection = 1
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 1, 1, 0]
+
+ nms, _ = post_processing.class_agnostic_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_classes_per_detection,
+ max_output_size)
+
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)
+ ])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ # Two cases will be tested here: using / not using static shapes.
+ # Named the two test cases for easier control during testing, with a flag of
+ # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1'
+ # or
+ # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1_use_static_shapes'.
+ @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+ def test_batch_classagnostic_nms_with_batch_size_1(self,
+ use_static_shapes=False):
+ boxes = tf.constant(
+ [[[[0, 0, 1, 1]], [[0, 0.1, 1, 1.1]], [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]], [[0, 10.1, 1, 11.1]], [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]], [[0, 1000, 1, 1002.1]]]], tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05], [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01], [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+ max_classes_per_detection = 1
+ use_class_agnostic_nms = True
+
+ exp_nms_corners = [[[0, 10, 1, 11], [0, 0, 1, 1], [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]]
+ exp_nms_scores = [[.95, .9, .85, .3]]
+ exp_nms_classes = [[0, 0, 1, 0]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields,
+ num_detections) = post_processing.batch_multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class=max_output_size,
+ max_total_size=max_output_size,
+ use_class_agnostic_nms=use_class_agnostic_nms,
+ use_static_shapes=use_static_shapes,
+ max_classes_per_detection=max_classes_per_detection)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, num_detections) = sess.run(
+ [nmsed_boxes, nmsed_scores, nmsed_classes, num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertEqual(num_detections, [4])
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/data_decoder.py b/Computer Vision/Plant_Disease_Detection_System/core/data_decoder.py
new file mode 100644
index 00000000..87ddf72c
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/data_decoder.py
@@ -0,0 +1,44 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Interface for data decoders.
+
+Data decoders decode the input data and return a dictionary of tensors keyed by
+the entries in core.reader.Fields.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from abc import ABCMeta
+from abc import abstractmethod
+import six
+
+
+class DataDecoder(six.with_metaclass(ABCMeta, object)):
+ """Interface for data decoders."""
+
+ @abstractmethod
+ def decode(self, data):
+ """Return a single image and associated labels.
+
+ Args:
+ data: a string tensor holding a serialized protocol buffer corresponding
+ to data for a single image.
+
+ Returns:
+ tensor_dict: a dictionary containing tensors. Possible keys are defined in
+ reader.Fields.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/data_parser.py b/Computer Vision/Plant_Disease_Detection_System/core/data_parser.py
new file mode 100644
index 00000000..889545db
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/data_parser.py
@@ -0,0 +1,45 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Interface for data parsers.
+
+Data parser parses input data and returns a dictionary of numpy arrays
+keyed by the entries in standard_fields.py. Since the parser parses records
+to numpy arrays (materialized tensors) directly, it is used to read data for
+evaluation/visualization; to parse the data during training, DataDecoder should
+be used.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from abc import ABCMeta
+from abc import abstractmethod
+import six
+
+
+class DataToNumpyParser(six.with_metaclass(ABCMeta, object)):
+ """Abstract interface for data parser that produces numpy arrays."""
+
+ @abstractmethod
+ def parse(self, input_data):
+ """Parses input and returns a numpy array or a dictionary of numpy arrays.
+
+ Args:
+ input_data: an input data
+
+ Returns:
+ A numpy array or a dictionary of numpy arrays or None, if input
+ cannot be parsed.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm.py b/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm.py
new file mode 100644
index 00000000..be82fcd2
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm.py
@@ -0,0 +1,68 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A freezable batch norm layer that uses Keras batch normalization."""
+import tensorflow as tf
+
+
+class FreezableBatchNorm(tf.keras.layers.BatchNormalization):
+ """Batch normalization layer (Ioffe and Szegedy, 2014).
+
+ This is a `freezable` batch norm layer that supports setting the `training`
+ parameter in the __init__ method rather than having to set it either via
+ the Keras learning phase or via the `call` method parameter. This layer will
+ forward all other parameters to the default Keras `BatchNormalization`
+ layer
+
+ This is class is necessary because Object Detection model training sometimes
+ requires batch normalization layers to be `frozen` and used as if it was
+ evaluation time, despite still training (and potentially using dropout layers)
+
+ Like the default Keras BatchNormalization layer, this will normalize the
+ activations of the previous layer at each batch,
+ i.e. applies a transformation that maintains the mean activation
+ close to 0 and the activation standard deviation close to 1.
+
+ Arguments:
+ training: If False, the layer will normalize using the moving average and
+ std. dev, without updating the learned avg and std. dev.
+ If None or True, the layer will follow the keras BatchNormalization layer
+ strategy of checking the Keras learning phase at `call` time to decide
+ what to do.
+ **kwargs: The keyword arguments to forward to the keras BatchNormalization
+ layer constructor.
+
+ Input shape:
+ Arbitrary. Use the keyword argument `input_shape`
+ (tuple of integers, does not include the samples axis)
+ when using this layer as the first layer in a model.
+
+ Output shape:
+ Same shape as input.
+
+ References:
+ - [Batch Normalization: Accelerating Deep Network Training by Reducing
+ Internal Covariate Shift](https://arxiv.org/abs/1502.03167)
+ """
+
+ def __init__(self, training=None, **kwargs):
+ super(FreezableBatchNorm, self).__init__(**kwargs)
+ self._training = training
+
+ def call(self, inputs, training=None):
+ # Override the call arg only if the batchnorm is frozen. (Ignore None)
+ if self._training is False: # pylint: disable=g-bool-id-comparison
+ training = self._training
+ return super(FreezableBatchNorm, self).call(inputs, training=training)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm_test.py b/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm_test.py
new file mode 100644
index 00000000..3e061526
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/freezable_batch_norm_test.py
@@ -0,0 +1,189 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.freezable_batch_norm."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import freezable_batch_norm
+
+
+class FreezableBatchNormTest(tf.test.TestCase):
+ """Tests for FreezableBatchNorm operations."""
+
+ def _build_model(self, training=None):
+ model = tf.keras.models.Sequential()
+ norm = freezable_batch_norm.FreezableBatchNorm(training=training,
+ input_shape=(10,),
+ momentum=0.8)
+ model.add(norm)
+ return model, norm
+
+ def _train_freezable_batch_norm(self, training_mean, training_var):
+ model, _ = self._build_model()
+ model.compile(loss='mse', optimizer='sgd')
+
+ # centered on training_mean, variance training_var
+ train_data = np.random.normal(
+ loc=training_mean,
+ scale=training_var,
+ size=(1000, 10))
+ model.fit(train_data, train_data, epochs=4, verbose=0)
+ return model.weights
+
+ def _test_batchnorm_layer(
+ self, norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg, training_mean, training_var):
+ out_tensor = norm(tf.convert_to_tensor(test_data, dtype=tf.float32),
+ training=training_arg)
+ out = tf.keras.backend.eval(out_tensor)
+ out -= tf.keras.backend.eval(norm.beta)
+ out /= tf.keras.backend.eval(norm.gamma)
+
+ if not should_be_training:
+ out *= training_var
+ out += (training_mean - testing_mean)
+ out /= testing_var
+
+ np.testing.assert_allclose(out.mean(), 0.0, atol=1.5e-1)
+ np.testing.assert_allclose(out.std(), 1.0, atol=1.5e-1)
+
+ def test_batchnorm_freezing_training_none(self):
+ with self.test_session():
+ training_mean = 5.0
+ training_var = 10.0
+
+ testing_mean = -10.0
+ testing_var = 5.0
+
+ # Initially train the batch norm, and save the weights
+ trained_weights = self._train_freezable_batch_norm(training_mean,
+ training_var)
+
+ # Load the batch norm weights, freezing training to True.
+ # Apply the batch norm layer to testing data and ensure it is normalized
+ # according to the batch statistics.
+ model, norm = self._build_model(training=True)
+ for trained_weight, blank_weight in zip(trained_weights, model.weights):
+ weight_copy = blank_weight.assign(tf.keras.backend.eval(trained_weight))
+ tf.keras.backend.eval(weight_copy)
+
+ # centered on testing_mean, variance testing_var
+ test_data = np.random.normal(
+ loc=testing_mean,
+ scale=testing_var,
+ size=(1000, 10))
+
+ # Test with training=True passed to the call method:
+ training_arg = True
+ should_be_training = True
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test with training=False passed to the call method:
+ training_arg = False
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test the layer in various Keras learning phase scopes:
+ training_arg = None
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(True)
+ should_be_training = True
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(False)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ def test_batchnorm_freezing_training_false(self):
+ with self.test_session():
+ training_mean = 5.0
+ training_var = 10.0
+
+ testing_mean = -10.0
+ testing_var = 5.0
+
+ # Initially train the batch norm, and save the weights
+ trained_weights = self._train_freezable_batch_norm(training_mean,
+ training_var)
+
+ # Load the batch norm back up, freezing training to False.
+ # Apply the batch norm layer to testing data and ensure it is normalized
+ # according to the training data's statistics.
+ model, norm = self._build_model(training=False)
+ for trained_weight, blank_weight in zip(trained_weights, model.weights):
+ weight_copy = blank_weight.assign(tf.keras.backend.eval(trained_weight))
+ tf.keras.backend.eval(weight_copy)
+
+ # centered on testing_mean, variance testing_var
+ test_data = np.random.normal(
+ loc=testing_mean,
+ scale=testing_var,
+ size=(1000, 10))
+
+ # Make sure that the layer is never training
+ # Test with training=True passed to the call method:
+ training_arg = True
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test with training=False passed to the call method:
+ training_arg = False
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test the layer in various Keras learning phase scopes:
+ training_arg = None
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(True)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(False)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops.py b/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops.py
new file mode 100644
index 00000000..e520845f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops.py
@@ -0,0 +1,282 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Keypoint operations.
+
+Keypoints are represented as tensors of shape [num_instances, num_keypoints, 2],
+where the last dimension holds rank 2 tensors of the form [y, x] representing
+the coordinates of the keypoint.
+"""
+import numpy as np
+import tensorflow as tf
+
+
+def scale(keypoints, y_scale, x_scale, scope=None):
+ """Scales keypoint coordinates in x and y dimensions.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ y_scale: (float) scalar tensor
+ x_scale: (float) scalar tensor
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'Scale'):
+ y_scale = tf.cast(y_scale, tf.float32)
+ x_scale = tf.cast(x_scale, tf.float32)
+ new_keypoints = keypoints * [[[y_scale, x_scale]]]
+ return new_keypoints
+
+
+def clip_to_window(keypoints, window, scope=None):
+ """Clips keypoints to a window.
+
+ This op clips any input keypoints to a window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window to which the op should clip the keypoints.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'ClipToWindow'):
+ y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ y = tf.maximum(tf.minimum(y, win_y_max), win_y_min)
+ x = tf.maximum(tf.minimum(x, win_x_max), win_x_min)
+ new_keypoints = tf.concat([y, x], 2)
+ return new_keypoints
+
+
+def prune_outside_window(keypoints, window, scope=None):
+ """Prunes keypoints that fall outside a given window.
+
+ This function replaces keypoints that fall outside the given window with nan.
+ See also clip_to_window which clips any keypoints that fall outside the given
+ window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window outside of which the op should prune the keypoints.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'PruneOutsideWindow'):
+ y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+
+ valid_indices = tf.logical_and(
+ tf.logical_and(y >= win_y_min, y <= win_y_max),
+ tf.logical_and(x >= win_x_min, x <= win_x_max))
+
+ new_y = tf.where(valid_indices, y, np.nan * tf.ones_like(y))
+ new_x = tf.where(valid_indices, x, np.nan * tf.ones_like(x))
+ new_keypoints = tf.concat([new_y, new_x], 2)
+
+ return new_keypoints
+
+
+def change_coordinate_frame(keypoints, window, scope=None):
+ """Changes coordinate frame of the keypoints to be relative to window's frame.
+
+ Given a window of the form [y_min, x_min, y_max, x_max], changes keypoint
+ coordinates from keypoints of shape [num_instances, num_keypoints, 2]
+ to be relative to this window.
+
+ An example use case is data augmentation: where we are given groundtruth
+ keypoints and would like to randomly crop the image to some window. In this
+ case we need to change the coordinate frame of each groundtruth keypoint to be
+ relative to this new window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window we should change the coordinate frame to.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'ChangeCoordinateFrame'):
+ win_height = window[2] - window[0]
+ win_width = window[3] - window[1]
+ new_keypoints = scale(keypoints - [window[0], window[1]], 1.0 / win_height,
+ 1.0 / win_width)
+ return new_keypoints
+
+
+def to_normalized_coordinates(keypoints, height, width,
+ check_range=True, scope=None):
+ """Converts absolute keypoint coordinates to normalized coordinates in [0, 1].
+
+ Usually one uses the dynamic shape of the image or conv-layer tensor:
+ keypoints = keypoint_ops.to_normalized_coordinates(keypoints,
+ tf.shape(images)[1],
+ tf.shape(images)[2]),
+
+ This function raises an assertion failed error at graph execution time when
+ the maximum coordinate is smaller than 1.01 (which means that coordinates are
+ already normalized). The value 1.01 is to deal with small rounding errors.
+
+ Args:
+ keypoints: A tensor of shape [num_instances, num_keypoints, 2].
+ height: Maximum value for y coordinate of absolute keypoint coordinates.
+ width: Maximum value for x coordinate of absolute keypoint coordinates.
+ check_range: If True, checks if the coordinates are normalized.
+ scope: name scope.
+
+ Returns:
+ tensor of shape [num_instances, num_keypoints, 2] with normalized
+ coordinates in [0, 1].
+ """
+ with tf.name_scope(scope, 'ToNormalizedCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ if check_range:
+ max_val = tf.reduce_max(keypoints)
+ max_assert = tf.Assert(tf.greater(max_val, 1.01),
+ ['max value is lower than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(keypoints, 1.0 / height, 1.0 / width)
+
+
+def to_absolute_coordinates(keypoints, height, width,
+ check_range=True, scope=None):
+ """Converts normalized keypoint coordinates to absolute pixel coordinates.
+
+ This function raises an assertion failed error when the maximum keypoint
+ coordinate value is larger than 1.01 (in which case coordinates are already
+ absolute).
+
+ Args:
+ keypoints: A tensor of shape [num_instances, num_keypoints, 2]
+ height: Maximum value for y coordinate of absolute keypoint coordinates.
+ width: Maximum value for x coordinate of absolute keypoint coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ scope: name scope.
+
+ Returns:
+ tensor of shape [num_instances, num_keypoints, 2] with absolute coordinates
+ in terms of the image size.
+
+ """
+ with tf.name_scope(scope, 'ToAbsoluteCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ # Ensure range of input keypoints is correct.
+ if check_range:
+ max_val = tf.reduce_max(keypoints)
+ max_assert = tf.Assert(tf.greater_equal(1.01, max_val),
+ ['maximum keypoint coordinate value is larger '
+ 'than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(keypoints, height, width)
+
+
+def flip_horizontal(keypoints, flip_point, flip_permutation, scope=None):
+ """Flips the keypoints horizontally around the flip_point.
+
+ This operation flips the x coordinate for each keypoint around the flip_point
+ and also permutes the keypoints in a manner specified by flip_permutation.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ flip_point: (float) scalar tensor representing the x coordinate to flip the
+ keypoints around.
+ flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation. This specifies the mapping from original keypoint indices
+ to the flipped keypoint indices. This is used primarily for keypoints
+ that are not reflection invariant. E.g. Suppose there are 3 keypoints
+ representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+ flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+ and 'right_eye' after a horizontal flip.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'FlipHorizontal'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ keypoints = tf.gather(keypoints, flip_permutation)
+ v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ u = flip_point * 2.0 - u
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
+
+
+def flip_vertical(keypoints, flip_point, flip_permutation, scope=None):
+ """Flips the keypoints vertically around the flip_point.
+
+ This operation flips the y coordinate for each keypoint around the flip_point
+ and also permutes the keypoints in a manner specified by flip_permutation.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ flip_point: (float) scalar tensor representing the y coordinate to flip the
+ keypoints around.
+ flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation. This specifies the mapping from original keypoint indices
+ to the flipped keypoint indices. This is used primarily for keypoints
+ that are not reflection invariant. E.g. Suppose there are 3 keypoints
+ representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+ flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+ and 'right_eye' after a horizontal flip.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'FlipVertical'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ keypoints = tf.gather(keypoints, flip_permutation)
+ v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ v = flip_point * 2.0 - v
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
+
+
+def rot90(keypoints, scope=None):
+ """Rotates the keypoints counter-clockwise by 90 degrees.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'Rot90'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ v, u = tf.split(value=keypoints[:, :, ::-1], num_or_size_splits=2, axis=2)
+ v = 1.0 - v
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops_test.py b/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops_test.py
new file mode 100644
index 00000000..1c09c55a
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/keypoint_ops_test.py
@@ -0,0 +1,200 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.keypoint_ops."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import keypoint_ops
+
+
+class KeypointOpsTest(tf.test.TestCase):
+ """Tests for common keypoint operations."""
+
+ def test_scale(self):
+ keypoints = tf.constant([
+ [[0.0, 0.0], [100.0, 200.0]],
+ [[50.0, 120.0], [100.0, 140.0]]
+ ])
+ y_scale = tf.constant(1.0 / 100)
+ x_scale = tf.constant(1.0 / 200)
+
+ expected_keypoints = tf.constant([
+ [[0., 0.], [1.0, 1.0]],
+ [[0.5, 0.6], [1.0, 0.7]]
+ ])
+ output = keypoint_ops.scale(keypoints, y_scale, x_scale)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_clip_to_window(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.25], [0.75, 0.75]]
+ ])
+ output = keypoint_ops.clip_to_window(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_prune_outside_window(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([[[0.25, 0.5], [0.75, 0.75]],
+ [[np.nan, np.nan], [np.nan, np.nan]]])
+ output = keypoint_ops.prune_outside_window(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_change_coordinate_frame(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([
+ [[0, 0.5], [1.0, 1.0]],
+ [[0.5, -0.5], [1.5, 1.5]]
+ ])
+ output = keypoint_ops.change_coordinate_frame(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_normalized_coordinates(self):
+ keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+ output = keypoint_ops.to_normalized_coordinates(
+ keypoints, 40, 60)
+ expected_keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_normalized_coordinates_already_normalized(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ output = keypoint_ops.to_normalized_coordinates(
+ keypoints, 40, 60)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(output)
+
+ def test_to_absolute_coordinates(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ output = keypoint_ops.to_absolute_coordinates(
+ keypoints, 40, 60)
+ expected_keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_absolute_coordinates_already_absolute(self):
+ keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+ output = keypoint_ops.to_absolute_coordinates(
+ keypoints, 40, 60)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(output)
+
+ def test_flip_horizontal(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]
+ ])
+ flip_permutation = [0, 2, 1]
+
+ expected_keypoints = tf.constant([
+ [[0.1, 0.9], [0.3, 0.7], [0.2, 0.8]],
+ [[0.4, 0.6], [0.6, 0.4], [0.5, 0.5]],
+ ])
+ output = keypoint_ops.flip_horizontal(keypoints, 0.5, flip_permutation)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_flip_vertical(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]
+ ])
+ flip_permutation = [0, 2, 1]
+
+ expected_keypoints = tf.constant([
+ [[0.9, 0.1], [0.7, 0.3], [0.8, 0.2]],
+ [[0.6, 0.4], [0.4, 0.6], [0.5, 0.5]],
+ ])
+ output = keypoint_ops.flip_vertical(keypoints, 0.5, flip_permutation)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_rot90(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.6], [0.5, 0.6], [0.6, 0.7]]
+ ])
+ expected_keypoints = tf.constant([
+ [[0.9, 0.1], [0.8, 0.2], [0.7, 0.3]],
+ [[0.4, 0.4], [0.4, 0.5], [0.3, 0.6]],
+ ])
+ output = keypoint_ops.rot90(keypoints)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/losses.py b/Computer Vision/Plant_Disease_Detection_System/core/losses.py
new file mode 100644
index 00000000..b4fa4286
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/losses.py
@@ -0,0 +1,686 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Classification and regression loss functions for object detection.
+
+Localization losses:
+ * WeightedL2LocalizationLoss
+ * WeightedSmoothL1LocalizationLoss
+ * WeightedIOULocalizationLoss
+
+Classification losses:
+ * WeightedSigmoidClassificationLoss
+ * WeightedSoftmaxClassificationLoss
+ * WeightedSoftmaxClassificationAgainstLogitsLoss
+ * BootstrappedSigmoidClassificationLoss
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import abc
+import six
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.utils import ops
+
+slim = tf.contrib.slim
+
+
+class Loss(six.with_metaclass(abc.ABCMeta, object)):
+ """Abstract base class for loss functions."""
+
+ def __call__(self,
+ prediction_tensor,
+ target_tensor,
+ ignore_nan_targets=False,
+ losses_mask=None,
+ scope=None,
+ **params):
+ """Call the loss function.
+
+ Args:
+ prediction_tensor: an N-d tensor of shape [batch, anchors, ...]
+ representing predicted quantities.
+ target_tensor: an N-d tensor of shape [batch, anchors, ...] representing
+ regression or classification targets.
+ ignore_nan_targets: whether to ignore nan targets in the loss computation.
+ E.g. can be used if the target tensor is missing groundtruth data that
+ shouldn't be factored into the loss.
+ losses_mask: A [batch] boolean tensor that indicates whether losses should
+ be applied to individual images in the batch. For elements that
+ are False, corresponding prediction, target, and weight tensors will not
+ contribute to loss computation. If None, no filtering will take place
+ prior to loss computation.
+ scope: Op scope name. Defaults to 'Loss' if None.
+ **params: Additional keyword arguments for specific implementations of
+ the Loss.
+
+ Returns:
+ loss: a tensor representing the value of the loss function.
+ """
+ with tf.name_scope(scope, 'Loss',
+ [prediction_tensor, target_tensor, params]) as scope:
+ if ignore_nan_targets:
+ target_tensor = tf.where(tf.is_nan(target_tensor),
+ prediction_tensor,
+ target_tensor)
+ if losses_mask is not None:
+ tensor_multiplier = self._get_loss_multiplier_for_tensor(
+ prediction_tensor,
+ losses_mask)
+ prediction_tensor *= tensor_multiplier
+ target_tensor *= tensor_multiplier
+
+ if 'weights' in params:
+ params['weights'] = tf.convert_to_tensor(params['weights'])
+ weights_multiplier = self._get_loss_multiplier_for_tensor(
+ params['weights'],
+ losses_mask)
+ params['weights'] *= weights_multiplier
+ return self._compute_loss(prediction_tensor, target_tensor, **params)
+
+ def _get_loss_multiplier_for_tensor(self, tensor, losses_mask):
+ loss_multiplier_shape = tf.stack([-1] + [1] * (len(tensor.shape) - 1))
+ return tf.cast(tf.reshape(losses_mask, loss_multiplier_shape), tf.float32)
+
+ @abc.abstractmethod
+ def _compute_loss(self, prediction_tensor, target_tensor, **params):
+ """Method to be overridden by implementations.
+
+ Args:
+ prediction_tensor: a tensor representing predicted quantities
+ target_tensor: a tensor representing regression or classification targets
+ **params: Additional keyword arguments for specific implementations of
+ the Loss.
+
+ Returns:
+ loss: an N-d tensor of shape [batch, anchors, ...] containing the loss per
+ anchor
+ """
+ pass
+
+
+class WeightedL2LocalizationLoss(Loss):
+ """L2 localization loss function with anchorwise output support.
+
+ Loss[b,a] = .5 * ||weights[b,a] * (prediction[b,a,:] - target[b,a,:])||^2
+ """
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the (encoded) predicted locations of objects.
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the regression targets
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ weighted_diff = (prediction_tensor - target_tensor) * tf.expand_dims(
+ weights, 2)
+ square_diff = 0.5 * tf.square(weighted_diff)
+ return tf.reduce_sum(square_diff, 2)
+
+
+class WeightedSmoothL1LocalizationLoss(Loss):
+ """Smooth L1 localization loss function aka Huber Loss..
+
+ The smooth L1_loss is defined elementwise as .5 x^2 if |x| <= delta and
+ delta * (|x|- 0.5*delta) otherwise, where x is the difference between
+ predictions and target.
+
+ See also Equation (3) in the Fast R-CNN paper by Ross Girshick (ICCV 2015)
+ """
+
+ def __init__(self, delta=1.0):
+ """Constructor.
+
+ Args:
+ delta: delta for smooth L1 loss.
+ """
+ super(WeightedSmoothL1LocalizationLoss, self).__init__()
+ self._delta = delta
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the (encoded) predicted locations of objects.
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the regression targets
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ return tf.reduce_sum(tf.losses.huber_loss(
+ target_tensor,
+ prediction_tensor,
+ delta=self._delta,
+ weights=tf.expand_dims(weights, axis=2),
+ loss_collection=None,
+ reduction=tf.losses.Reduction.NONE
+ ), axis=2)
+
+
+class WeightedIOULocalizationLoss(Loss):
+ """IOU localization loss function.
+
+ Sums the IOU for corresponding pairs of predicted/groundtruth boxes
+ and for each pair assign a loss of 1 - IOU. We then compute a weighted
+ sum over all pairs which is returned as the total loss.
+ """
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors, 4]
+ representing the decoded predicted boxes
+ target_tensor: A float tensor of shape [batch_size, num_anchors, 4]
+ representing the decoded target boxes
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ predicted_boxes = box_list.BoxList(tf.reshape(prediction_tensor, [-1, 4]))
+ target_boxes = box_list.BoxList(tf.reshape(target_tensor, [-1, 4]))
+ per_anchor_iou_loss = 1.0 - box_list_ops.matched_iou(predicted_boxes,
+ target_boxes)
+ return tf.reshape(weights, [-1]) * per_anchor_iou_loss
+
+
+class WeightedSigmoidClassificationLoss(Loss):
+ """Sigmoid cross entropy classification loss function."""
+
+ def _compute_loss(self,
+ prediction_tensor,
+ target_tensor,
+ weights,
+ class_indices=None):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+ class_indices: (Optional) A 1-D integer tensor of class indices.
+ If provided, computes loss only for the specified class indices.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if class_indices is not None:
+ weights *= tf.reshape(
+ ops.indices_to_dense_vector(class_indices,
+ tf.shape(prediction_tensor)[2]),
+ [1, 1, -1])
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=target_tensor, logits=prediction_tensor))
+ return per_entry_cross_ent * weights
+
+
+class SigmoidFocalClassificationLoss(Loss):
+ """Sigmoid focal cross entropy loss.
+
+ Focal loss down-weights well classified examples and focusses on the hard
+ examples. See https://arxiv.org/pdf/1708.02002.pdf for the loss definition.
+ """
+
+ def __init__(self, gamma=2.0, alpha=0.25):
+ """Constructor.
+
+ Args:
+ gamma: exponent of the modulating factor (1 - p_t) ^ gamma.
+ alpha: optional alpha weighting factor to balance positives vs negatives.
+ """
+ super(SigmoidFocalClassificationLoss, self).__init__()
+ self._alpha = alpha
+ self._gamma = gamma
+
+ def _compute_loss(self,
+ prediction_tensor,
+ target_tensor,
+ weights,
+ class_indices=None):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+ class_indices: (Optional) A 1-D integer tensor of class indices.
+ If provided, computes loss only for the specified class indices.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if class_indices is not None:
+ weights *= tf.reshape(
+ ops.indices_to_dense_vector(class_indices,
+ tf.shape(prediction_tensor)[2]),
+ [1, 1, -1])
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=target_tensor, logits=prediction_tensor))
+ prediction_probabilities = tf.sigmoid(prediction_tensor)
+ p_t = ((target_tensor * prediction_probabilities) +
+ ((1 - target_tensor) * (1 - prediction_probabilities)))
+ modulating_factor = 1.0
+ if self._gamma:
+ modulating_factor = tf.pow(1.0 - p_t, self._gamma)
+ alpha_weight_factor = 1.0
+ if self._alpha is not None:
+ alpha_weight_factor = (target_tensor * self._alpha +
+ (1 - target_tensor) * (1 - self._alpha))
+ focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor *
+ per_entry_cross_ent)
+ return focal_cross_entropy_loss * weights
+
+
+class WeightedSoftmaxClassificationLoss(Loss):
+ """Softmax loss function."""
+
+ def __init__(self, logit_scale=1.0):
+ """Constructor.
+
+ Args:
+ logit_scale: When this value is high, the prediction is "diffused" and
+ when this value is low, the prediction is made peakier.
+ (default 1.0)
+
+ """
+ super(WeightedSoftmaxClassificationLoss, self).__init__()
+ self._logit_scale = logit_scale
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors]
+ representing the value of the loss function.
+ """
+ weights = tf.reduce_mean(weights, axis=2)
+ num_classes = prediction_tensor.get_shape().as_list()[-1]
+ prediction_tensor = tf.divide(
+ prediction_tensor, self._logit_scale, name='scale_logit')
+ per_row_cross_ent = (tf.nn.softmax_cross_entropy_with_logits(
+ labels=tf.reshape(target_tensor, [-1, num_classes]),
+ logits=tf.reshape(prediction_tensor, [-1, num_classes])))
+ return tf.reshape(per_row_cross_ent, tf.shape(weights)) * weights
+
+
+class WeightedSoftmaxClassificationAgainstLogitsLoss(Loss):
+ """Softmax loss function against logits.
+
+ Targets are expected to be provided in logits space instead of "one hot" or
+ "probability distribution" space.
+ """
+
+ def __init__(self, logit_scale=1.0):
+ """Constructor.
+
+ Args:
+ logit_scale: When this value is high, the target is "diffused" and
+ when this value is low, the target is made peakier.
+ (default 1.0)
+
+ """
+ super(WeightedSoftmaxClassificationAgainstLogitsLoss, self).__init__()
+ self._logit_scale = logit_scale
+
+ def _scale_and_softmax_logits(self, logits):
+ """Scale logits then apply softmax."""
+ scaled_logits = tf.divide(logits, self._logit_scale, name='scale_logits')
+ return tf.nn.softmax(scaled_logits, name='convert_scores')
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing logit classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors]
+ representing the value of the loss function.
+ """
+ weights = tf.reduce_mean(weights, axis=2)
+ num_classes = prediction_tensor.get_shape().as_list()[-1]
+ target_tensor = self._scale_and_softmax_logits(target_tensor)
+ prediction_tensor = tf.divide(prediction_tensor, self._logit_scale,
+ name='scale_logits')
+
+ per_row_cross_ent = (tf.nn.softmax_cross_entropy_with_logits(
+ labels=tf.reshape(target_tensor, [-1, num_classes]),
+ logits=tf.reshape(prediction_tensor, [-1, num_classes])))
+ return tf.reshape(per_row_cross_ent, tf.shape(weights)) * weights
+
+
+class BootstrappedSigmoidClassificationLoss(Loss):
+ """Bootstrapped sigmoid cross entropy classification loss function.
+
+ This loss uses a convex combination of training labels and the current model's
+ predictions as training targets in the classification loss. The idea is that
+ as the model improves over time, its predictions can be trusted more and we
+ can use these predictions to mitigate the damage of noisy/incorrect labels,
+ because incorrect labels are likely to be eventually highly inconsistent with
+ other stimuli predicted to have the same label by the model.
+
+ In "soft" bootstrapping, we use all predicted class probabilities, whereas in
+ "hard" bootstrapping, we use the single class favored by the model.
+
+ See also Training Deep Neural Networks On Noisy Labels with Bootstrapping by
+ Reed et al. (ICLR 2015).
+ """
+
+ def __init__(self, alpha, bootstrap_type='soft'):
+ """Constructor.
+
+ Args:
+ alpha: a float32 scalar tensor between 0 and 1 representing interpolation
+ weight
+ bootstrap_type: set to either 'hard' or 'soft' (default)
+
+ Raises:
+ ValueError: if bootstrap_type is not either 'hard' or 'soft'
+ """
+ super(BootstrappedSigmoidClassificationLoss, self).__init__()
+ if bootstrap_type != 'hard' and bootstrap_type != 'soft':
+ raise ValueError('Unrecognized bootstrap_type: must be one of '
+ '\'hard\' or \'soft.\'')
+ self._alpha = alpha
+ self._bootstrap_type = bootstrap_type
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if self._bootstrap_type == 'soft':
+ bootstrap_target_tensor = self._alpha * target_tensor + (
+ 1.0 - self._alpha) * tf.sigmoid(prediction_tensor)
+ else:
+ bootstrap_target_tensor = self._alpha * target_tensor + (
+ 1.0 - self._alpha) * tf.cast(
+ tf.sigmoid(prediction_tensor) > 0.5, tf.float32)
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=bootstrap_target_tensor, logits=prediction_tensor))
+ return per_entry_cross_ent * weights
+
+
+class HardExampleMiner(object):
+ """Hard example mining for regions in a list of images.
+
+ Implements hard example mining to select a subset of regions to be
+ back-propagated. For each image, selects the regions with highest losses,
+ subject to the condition that a newly selected region cannot have
+ an IOU > iou_threshold with any of the previously selected regions.
+ This can be achieved by re-using a greedy non-maximum suppression algorithm.
+ A constraint on the number of negatives mined per positive region can also be
+ enforced.
+
+ Reference papers: "Training Region-based Object Detectors with Online
+ Hard Example Mining" (CVPR 2016) by Srivastava et al., and
+ "SSD: Single Shot MultiBox Detector" (ECCV 2016) by Liu et al.
+ """
+
+ def __init__(self,
+ num_hard_examples=64,
+ iou_threshold=0.7,
+ loss_type='both',
+ cls_loss_weight=0.05,
+ loc_loss_weight=0.06,
+ max_negatives_per_positive=None,
+ min_negatives_per_image=0):
+ """Constructor.
+
+ The hard example mining implemented by this class can replicate the behavior
+ in the two aforementioned papers (Srivastava et al., and Liu et al).
+ To replicate the A2 paper (Srivastava et al), num_hard_examples is set
+ to a fixed parameter (64 by default) and iou_threshold is set to .7 for
+ running non-max-suppression the predicted boxes prior to hard mining.
+ In order to replicate the SSD paper (Liu et al), num_hard_examples should
+ be set to None, max_negatives_per_positive should be 3 and iou_threshold
+ should be 1.0 (in order to effectively turn off NMS).
+
+ Args:
+ num_hard_examples: maximum number of hard examples to be
+ selected per image (prior to enforcing max negative to positive ratio
+ constraint). If set to None, all examples obtained after NMS are
+ considered.
+ iou_threshold: minimum intersection over union for an example
+ to be discarded during NMS.
+ loss_type: use only classification losses ('cls', default),
+ localization losses ('loc') or both losses ('both').
+ In the last case, cls_loss_weight and loc_loss_weight are used to
+ compute weighted sum of the two losses.
+ cls_loss_weight: weight for classification loss.
+ loc_loss_weight: weight for location loss.
+ max_negatives_per_positive: maximum number of negatives to retain for
+ each positive anchor. By default, num_negatives_per_positive is None,
+ which means that we do not enforce a prespecified negative:positive
+ ratio. Note also that num_negatives_per_positives can be a float
+ (and will be converted to be a float even if it is passed in otherwise).
+ min_negatives_per_image: minimum number of negative anchors to sample for
+ a given image. Setting this to a positive number allows sampling
+ negatives in an image without any positive anchors and thus not biased
+ towards at least one detection per image.
+ """
+ self._num_hard_examples = num_hard_examples
+ self._iou_threshold = iou_threshold
+ self._loss_type = loss_type
+ self._cls_loss_weight = cls_loss_weight
+ self._loc_loss_weight = loc_loss_weight
+ self._max_negatives_per_positive = max_negatives_per_positive
+ self._min_negatives_per_image = min_negatives_per_image
+ if self._max_negatives_per_positive is not None:
+ self._max_negatives_per_positive = float(self._max_negatives_per_positive)
+ self._num_positives_list = None
+ self._num_negatives_list = None
+
+ def __call__(self,
+ location_losses,
+ cls_losses,
+ decoded_boxlist_list,
+ match_list=None):
+ """Computes localization and classification losses after hard mining.
+
+ Args:
+ location_losses: a float tensor of shape [num_images, num_anchors]
+ representing anchorwise localization losses.
+ cls_losses: a float tensor of shape [num_images, num_anchors]
+ representing anchorwise classification losses.
+ decoded_boxlist_list: a list of decoded BoxList representing location
+ predictions for each image.
+ match_list: an optional list of matcher.Match objects encoding the match
+ between anchors and groundtruth boxes for each image of the batch,
+ with rows of the Match objects corresponding to groundtruth boxes
+ and columns corresponding to anchors. Match objects in match_list are
+ used to reference which anchors are positive, negative or ignored. If
+ self._max_negatives_per_positive exists, these are then used to enforce
+ a prespecified negative to positive ratio.
+
+ Returns:
+ mined_location_loss: a float scalar with sum of localization losses from
+ selected hard examples.
+ mined_cls_loss: a float scalar with sum of classification losses from
+ selected hard examples.
+ Raises:
+ ValueError: if location_losses, cls_losses and decoded_boxlist_list do
+ not have compatible shapes (i.e., they must correspond to the same
+ number of images).
+ ValueError: if match_list is specified but its length does not match
+ len(decoded_boxlist_list).
+ """
+ mined_location_losses = []
+ mined_cls_losses = []
+ location_losses = tf.unstack(location_losses)
+ cls_losses = tf.unstack(cls_losses)
+ num_images = len(decoded_boxlist_list)
+ if not match_list:
+ match_list = num_images * [None]
+ if not len(location_losses) == len(decoded_boxlist_list) == len(cls_losses):
+ raise ValueError('location_losses, cls_losses and decoded_boxlist_list '
+ 'do not have compatible shapes.')
+ if not isinstance(match_list, list):
+ raise ValueError('match_list must be a list.')
+ if len(match_list) != len(decoded_boxlist_list):
+ raise ValueError('match_list must either be None or have '
+ 'length=len(decoded_boxlist_list).')
+ num_positives_list = []
+ num_negatives_list = []
+ for ind, detection_boxlist in enumerate(decoded_boxlist_list):
+ box_locations = detection_boxlist.get()
+ match = match_list[ind]
+ image_losses = cls_losses[ind]
+ if self._loss_type == 'loc':
+ image_losses = location_losses[ind]
+ elif self._loss_type == 'both':
+ image_losses *= self._cls_loss_weight
+ image_losses += location_losses[ind] * self._loc_loss_weight
+ if self._num_hard_examples is not None:
+ num_hard_examples = self._num_hard_examples
+ else:
+ num_hard_examples = detection_boxlist.num_boxes()
+ selected_indices = tf.image.non_max_suppression(
+ box_locations, image_losses, num_hard_examples, self._iou_threshold)
+ if self._max_negatives_per_positive is not None and match:
+ (selected_indices, num_positives,
+ num_negatives) = self._subsample_selection_to_desired_neg_pos_ratio(
+ selected_indices, match, self._max_negatives_per_positive,
+ self._min_negatives_per_image)
+ num_positives_list.append(num_positives)
+ num_negatives_list.append(num_negatives)
+ mined_location_losses.append(
+ tf.reduce_sum(tf.gather(location_losses[ind], selected_indices)))
+ mined_cls_losses.append(
+ tf.reduce_sum(tf.gather(cls_losses[ind], selected_indices)))
+ location_loss = tf.reduce_sum(tf.stack(mined_location_losses))
+ cls_loss = tf.reduce_sum(tf.stack(mined_cls_losses))
+ if match and self._max_negatives_per_positive:
+ self._num_positives_list = num_positives_list
+ self._num_negatives_list = num_negatives_list
+ return (location_loss, cls_loss)
+
+ def summarize(self):
+ """Summarize the number of positives and negatives after mining."""
+ if self._num_positives_list and self._num_negatives_list:
+ avg_num_positives = tf.reduce_mean(
+ tf.cast(self._num_positives_list, dtype=tf.float32))
+ avg_num_negatives = tf.reduce_mean(
+ tf.cast(self._num_negatives_list, dtype=tf.float32))
+ tf.summary.scalar('HardExampleMiner/NumPositives', avg_num_positives)
+ tf.summary.scalar('HardExampleMiner/NumNegatives', avg_num_negatives)
+
+ def _subsample_selection_to_desired_neg_pos_ratio(self,
+ indices,
+ match,
+ max_negatives_per_positive,
+ min_negatives_per_image=0):
+ """Subsample a collection of selected indices to a desired neg:pos ratio.
+
+ This function takes a subset of M indices (indexing into a large anchor
+ collection of N anchors where M=0,
+ meaning that column i is matched with row match_results[i].
+ (2) match_results[i]=-1, meaning that column i is not matched.
+ (3) match_results[i]=-2, meaning that column i is ignored.
+ use_matmul_gather: Use matrix multiplication based gather instead of
+ standard tf.gather. (Default: False).
+
+ Raises:
+ ValueError: if match_results does not have rank 1 or is not an
+ integer int32 scalar tensor
+ """
+ if match_results.shape.ndims != 1:
+ raise ValueError('match_results should have rank 1')
+ if match_results.dtype != tf.int32:
+ raise ValueError('match_results should be an int32 or int64 scalar '
+ 'tensor')
+ self._match_results = match_results
+ self._gather_op = tf.gather
+ if use_matmul_gather:
+ self._gather_op = ops.matmul_gather_on_zeroth_axis
+
+ @property
+ def match_results(self):
+ """The accessor for match results.
+
+ Returns:
+ the tensor which encodes the match results.
+ """
+ return self._match_results
+
+ def matched_column_indices(self):
+ """Returns column indices that match to some row.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.greater(self._match_results, -1)))
+
+ def matched_column_indicator(self):
+ """Returns column indices that are matched.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return tf.greater_equal(self._match_results, 0)
+
+ def num_matched_columns(self):
+ """Returns number (int32 scalar tensor) of matched columns."""
+ return tf.size(self.matched_column_indices())
+
+ def unmatched_column_indices(self):
+ """Returns column indices that do not match any row.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.equal(self._match_results, -1)))
+
+ def unmatched_column_indicator(self):
+ """Returns column indices that are unmatched.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return tf.equal(self._match_results, -1)
+
+ def num_unmatched_columns(self):
+ """Returns number (int32 scalar tensor) of unmatched columns."""
+ return tf.size(self.unmatched_column_indices())
+
+ def ignored_column_indices(self):
+ """Returns column indices that are ignored (neither Matched nor Unmatched).
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(self.ignored_column_indicator()))
+
+ def ignored_column_indicator(self):
+ """Returns boolean column indicator where True means the colum is ignored.
+
+ Returns:
+ column_indicator: boolean vector which is True for all ignored column
+ indices.
+ """
+ return tf.equal(self._match_results, -2)
+
+ def num_ignored_columns(self):
+ """Returns number (int32 scalar tensor) of matched columns."""
+ return tf.size(self.ignored_column_indices())
+
+ def unmatched_or_ignored_column_indices(self):
+ """Returns column indices that are unmatched or ignored.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.greater(0, self._match_results)))
+
+ def matched_row_indices(self):
+ """Returns row indices that match some column.
+
+ The indices returned by this op are ordered so as to be in correspondence
+ with the output of matched_column_indicator(). For example if
+ self.matched_column_indicator() is [0,2], and self.matched_row_indices() is
+ [7, 3], then we know that column 0 was matched to row 7 and column 2 was
+ matched to row 3.
+
+ Returns:
+ row_indices: int32 tensor of shape [K] with row indices.
+ """
+ return self._reshape_and_cast(
+ self._gather_op(tf.cast(self._match_results, dtype=tf.float32),
+ self.matched_column_indices()))
+
+ def num_matched_rows(self):
+ """Returns number (int32 scalar tensor) of matched rows."""
+ unique_rows, _ = tf.unique(self.matched_row_indices())
+ return tf.size(unique_rows)
+
+ def _reshape_and_cast(self, t):
+ return tf.cast(tf.reshape(t, [-1]), tf.int32)
+
+ def gather_based_on_match(self, input_tensor, unmatched_value,
+ ignored_value):
+ """Gathers elements from `input_tensor` based on match results.
+
+ For columns that are matched to a row, gathered_tensor[col] is set to
+ input_tensor[match_results[col]]. For columns that are unmatched,
+ gathered_tensor[col] is set to unmatched_value. Finally, for columns that
+ are ignored gathered_tensor[col] is set to ignored_value.
+
+ Note that the input_tensor.shape[1:] must match with unmatched_value.shape
+ and ignored_value.shape
+
+ Args:
+ input_tensor: Tensor to gather values from.
+ unmatched_value: Constant tensor value for unmatched columns.
+ ignored_value: Constant tensor value for ignored columns.
+
+ Returns:
+ gathered_tensor: A tensor containing values gathered from input_tensor.
+ The shape of the gathered tensor is [match_results.shape[0]] +
+ input_tensor.shape[1:].
+ """
+ input_tensor = tf.concat(
+ [tf.stack([ignored_value, unmatched_value]),
+ input_tensor],
+ axis=0)
+ gather_indices = tf.maximum(self.match_results + 2, 0)
+ gathered_tensor = self._gather_op(input_tensor, gather_indices)
+ return gathered_tensor
+
+
+class Matcher(six.with_metaclass(abc.ABCMeta, object)):
+ """Abstract base class for matcher.
+ """
+
+ def __init__(self, use_matmul_gather=False):
+ """Constructs a Matcher.
+
+ Args:
+ use_matmul_gather: Force constructed match objects to use matrix
+ multiplication based gather instead of standard tf.gather.
+ (Default: False).
+ """
+ self._use_matmul_gather = use_matmul_gather
+
+ def match(self, similarity_matrix, valid_rows=None, scope=None):
+ """Computes matches among row and column indices and returns the result.
+
+ Computes matches among the row and column indices based on the similarity
+ matrix and optional arguments.
+
+ Args:
+ similarity_matrix: Float tensor of shape [N, M] with pairwise similarity
+ where higher value means more similar.
+ valid_rows: A boolean tensor of shape [N] indicating the rows that are
+ valid for matching.
+ scope: Op scope name. Defaults to 'Match' if None.
+
+ Returns:
+ A Match object with the results of matching.
+ """
+ with tf.name_scope(scope, 'Match') as scope:
+ if valid_rows is None:
+ valid_rows = tf.ones(tf.shape(similarity_matrix)[0], dtype=tf.bool)
+ return Match(self._match(similarity_matrix, valid_rows),
+ self._use_matmul_gather)
+
+ @abc.abstractmethod
+ def _match(self, similarity_matrix, valid_rows):
+ """Method to be overridden by implementations.
+
+ Args:
+ similarity_matrix: Float tensor of shape [N, M] with pairwise similarity
+ where higher value means more similar.
+ valid_rows: A boolean tensor of shape [N] indicating the rows that are
+ valid for matching.
+ Returns:
+ match_results: Integer tensor of shape [M]: match_results[i]>=0 means
+ that column i is matched to row match_results[i], match_results[i]=-1
+ means that the column is not matched. match_results[i]=-2 means that
+ the column is ignored (usually this happens when there is a very weak
+ match which one neither wants as positive nor negative example).
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/matcher_test.py b/Computer Vision/Plant_Disease_Detection_System/core/matcher_test.py
new file mode 100644
index 00000000..1ed32167
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/matcher_test.py
@@ -0,0 +1,197 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.matcher."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import matcher
+
+
+class MatchTest(tf.test.TestCase):
+
+ def test_get_correct_matched_columnIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [0, 1, 3, 5]
+ matched_column_indices = match.matched_column_indices()
+ self.assertEqual(matched_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ matched_column_indices = sess.run(matched_column_indices)
+ self.assertAllEqual(matched_column_indices, expected_column_indices)
+
+ def test_get_correct_counts(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 1, -2])
+ match = matcher.Match(match_results)
+ exp_num_matched_columns = 4
+ exp_num_unmatched_columns = 2
+ exp_num_ignored_columns = 1
+ exp_num_matched_rows = 3
+ num_matched_columns = match.num_matched_columns()
+ num_unmatched_columns = match.num_unmatched_columns()
+ num_ignored_columns = match.num_ignored_columns()
+ num_matched_rows = match.num_matched_rows()
+ self.assertEqual(num_matched_columns.dtype, tf.int32)
+ self.assertEqual(num_unmatched_columns.dtype, tf.int32)
+ self.assertEqual(num_ignored_columns.dtype, tf.int32)
+ self.assertEqual(num_matched_rows.dtype, tf.int32)
+ with self.test_session() as sess:
+ (num_matched_columns_out, num_unmatched_columns_out,
+ num_ignored_columns_out, num_matched_rows_out) = sess.run(
+ [num_matched_columns, num_unmatched_columns, num_ignored_columns,
+ num_matched_rows])
+ self.assertAllEqual(num_matched_columns_out, exp_num_matched_columns)
+ self.assertAllEqual(num_unmatched_columns_out, exp_num_unmatched_columns)
+ self.assertAllEqual(num_ignored_columns_out, exp_num_ignored_columns)
+ self.assertAllEqual(num_matched_rows_out, exp_num_matched_rows)
+
+ def testGetCorrectUnmatchedColumnIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [2, 4]
+ unmatched_column_indices = match.unmatched_column_indices()
+ self.assertEqual(unmatched_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ unmatched_column_indices = sess.run(unmatched_column_indices)
+ self.assertAllEqual(unmatched_column_indices, expected_column_indices)
+
+ def testGetCorrectMatchedRowIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_row_indices = [3, 1, 0, 5]
+ matched_row_indices = match.matched_row_indices()
+ self.assertEqual(matched_row_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ matched_row_inds = sess.run(matched_row_indices)
+ self.assertAllEqual(matched_row_inds, expected_row_indices)
+
+ def test_get_correct_ignored_column_indices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [6]
+ ignored_column_indices = match.ignored_column_indices()
+ self.assertEqual(ignored_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ ignored_column_indices = sess.run(ignored_column_indices)
+ self.assertAllEqual(ignored_column_indices, expected_column_indices)
+
+ def test_get_correct_matched_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [True, True, False, True, False, True, False]
+ matched_column_indicator = match.matched_column_indicator()
+ self.assertEqual(matched_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ matched_column_indicator = sess.run(matched_column_indicator)
+ self.assertAllEqual(matched_column_indicator, expected_column_indicator)
+
+ def test_get_correct_unmatched_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [False, False, True, False, True, False, False]
+ unmatched_column_indicator = match.unmatched_column_indicator()
+ self.assertEqual(unmatched_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ unmatched_column_indicator = sess.run(unmatched_column_indicator)
+ self.assertAllEqual(unmatched_column_indicator, expected_column_indicator)
+
+ def test_get_correct_ignored_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [False, False, False, False, False, False, True]
+ ignored_column_indicator = match.ignored_column_indicator()
+ self.assertEqual(ignored_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ ignored_column_indicator = sess.run(ignored_column_indicator)
+ self.assertAllEqual(ignored_column_indicator, expected_column_indicator)
+
+ def test_get_correct_unmatched_ignored_column_indices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [2, 4, 6]
+ unmatched_ignored_column_indices = (match.
+ unmatched_or_ignored_column_indices())
+ self.assertEqual(unmatched_ignored_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ unmatched_ignored_column_indices = sess.run(
+ unmatched_ignored_column_indices)
+ self.assertAllEqual(unmatched_ignored_column_indices,
+ expected_column_indices)
+
+ def test_all_columns_accounted_for(self):
+ # Note: deliberately setting to small number so not always
+ # all possibilities appear (matched, unmatched, ignored)
+ num_matches = 10
+ match_results = tf.random_uniform(
+ [num_matches], minval=-2, maxval=5, dtype=tf.int32)
+ match = matcher.Match(match_results)
+ matched_column_indices = match.matched_column_indices()
+ unmatched_column_indices = match.unmatched_column_indices()
+ ignored_column_indices = match.ignored_column_indices()
+ with self.test_session() as sess:
+ matched, unmatched, ignored = sess.run([
+ matched_column_indices, unmatched_column_indices,
+ ignored_column_indices
+ ])
+ all_indices = np.hstack((matched, unmatched, ignored))
+ all_indices_sorted = np.sort(all_indices)
+ self.assertAllEqual(all_indices_sorted,
+ np.arange(num_matches, dtype=np.int32))
+
+ def test_scalar_gather_based_on_match(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ input_tensor = tf.constant([0, 1, 2, 3, 4, 5, 6, 7], dtype=tf.float32)
+ expected_gathered_tensor = [3, 1, 100, 0, 100, 5, 200]
+ match = matcher.Match(match_results)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=100.,
+ ignored_value=200.)
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session():
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+ def test_multidimensional_gather_based_on_match(self):
+ match_results = tf.constant([1, -1, -2])
+ input_tensor = tf.constant([[0, 0.5, 0, 0.5], [0, 0, 0.5, 0.5]],
+ dtype=tf.float32)
+ expected_gathered_tensor = [[0, 0, 0.5, 0.5], [0, 0, 0, 0], [0, 0, 0, 0]]
+ match = matcher.Match(match_results)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session():
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+ def test_multidimensional_gather_based_on_match_with_matmul_gather_op(self):
+ match_results = tf.constant([1, -1, -2])
+ input_tensor = tf.constant([[0, 0.5, 0, 0.5], [0, 0, 0.5, 0.5]],
+ dtype=tf.float32)
+ expected_gathered_tensor = [[0, 0, 0.5, 0.5], [0, 0, 0, 0], [0, 0, 0, 0]]
+ match = matcher.Match(match_results, use_matmul_gather=True)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session() as sess:
+ self.assertTrue(
+ all([op.name is not 'Gather' for op in sess.graph.get_operations()]))
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler.py b/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler.py
new file mode 100644
index 00000000..7628c8df
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler.py
@@ -0,0 +1,94 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base minibatch sampler module.
+
+The job of the minibatch_sampler is to subsample a minibatch based on some
+criterion.
+
+The main function call is:
+ subsample(indicator, batch_size, **params).
+Indicator is a 1d boolean tensor where True denotes which examples can be
+sampled. It returns a boolean indicator where True denotes an example has been
+sampled..
+
+Subclasses should implement the Subsample function and can make use of the
+@staticmethod SubsampleIndicator.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+import tensorflow as tf
+
+from object_detection.utils import ops
+
+
+class MinibatchSampler(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for subsampling minibatches."""
+
+ def __init__(self):
+ """Constructs a minibatch sampler."""
+ pass
+
+ @abstractmethod
+ def subsample(self, indicator, batch_size, **params):
+ """Returns subsample of entries in indicator.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ batch_size: desired batch size.
+ **params: additional keyword arguments for specific implementations of
+ the MinibatchSampler.
+
+ Returns:
+ sample_indicator: boolean tensor of shape [N] whose True entries have been
+ sampled. If sum(indicator) >= batch_size, sum(is_sampled) = batch_size
+ """
+ pass
+
+ @staticmethod
+ def subsample_indicator(indicator, num_samples):
+ """Subsample indicator vector.
+
+ Given a boolean indicator vector with M elements set to `True`, the function
+ assigns all but `num_samples` of these previously `True` elements to
+ `False`. If `num_samples` is greater than M, the original indicator vector
+ is returned.
+
+ Args:
+ indicator: a 1-dimensional boolean tensor indicating which elements
+ are allowed to be sampled and which are not.
+ num_samples: int32 scalar tensor
+
+ Returns:
+ a boolean tensor with the same shape as input (indicator) tensor
+ """
+ indices = tf.where(indicator)
+ indices = tf.random_shuffle(indices)
+ indices = tf.reshape(indices, [-1])
+
+ num_samples = tf.minimum(tf.size(indices), num_samples)
+ selected_indices = tf.slice(indices, [0], tf.reshape(num_samples, [1]))
+
+ selected_indicator = ops.indices_to_dense_vector(selected_indices,
+ tf.shape(indicator)[0])
+
+ return tf.equal(selected_indicator, 1)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler_test.py b/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler_test.py
new file mode 100644
index 00000000..7420ae5d
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/minibatch_sampler_test.py
@@ -0,0 +1,82 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for google3.research.vale.object_detection.minibatch_sampler."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import minibatch_sampler
+
+
+class MinibatchSamplerTest(tf.test.TestCase):
+
+ def test_subsample_indicator_when_more_true_elements_than_num_samples(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 3)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples)
+ self.assertTrue(np.sum(samples_out), 3)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_when_more_true_elements_than_num_samples_no_shape(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.placeholder(tf.bool)
+ feed_dict = {indicator: np_indicator}
+
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 3)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples, feed_dict=feed_dict)
+ self.assertTrue(np.sum(samples_out), 3)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_indicator_when_less_true_elements_than_num_samples(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 5)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples)
+ self.assertTrue(np.sum(samples_out), 4)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_indicator_when_num_samples_is_zero(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples_none = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 0)
+ with self.test_session() as sess:
+ samples_none_out = sess.run(samples_none)
+ self.assertAllEqual(
+ np.zeros_like(samples_none_out, dtype=bool),
+ samples_none_out)
+
+ def test_subsample_indicator_when_indicator_all_false(self):
+ indicator_empty = tf.zeros([0], dtype=tf.bool)
+ samples_empty = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator_empty, 4)
+ with self.test_session() as sess:
+ samples_empty_out = sess.run(samples_empty)
+ self.assertEqual(0, samples_empty_out.size)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/model.py b/Computer Vision/Plant_Disease_Detection_System/core/model.py
new file mode 100644
index 00000000..b04d6250
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/model.py
@@ -0,0 +1,375 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Abstract detection model.
+
+This file defines a generic base class for detection models. Programs that are
+designed to work with arbitrary detection models should only depend on this
+class. We intend for the functions in this class to follow tensor-in/tensor-out
+design, thus all functions have tensors or lists/dictionaries holding tensors as
+inputs and outputs.
+
+Abstractly, detection models predict output tensors given input images
+which can be passed to a loss function at training time or passed to a
+postprocessing function at eval time. The computation graphs at a high level
+consequently look as follows:
+
+Training time:
+inputs (images tensor) -> preprocess -> predict -> loss -> outputs (loss tensor)
+
+Evaluation time:
+inputs (images tensor) -> preprocess -> predict -> postprocess
+ -> outputs (boxes tensor, scores tensor, classes tensor, num_detections tensor)
+
+DetectionModels must thus implement four functions (1) preprocess, (2) predict,
+(3) postprocess and (4) loss. DetectionModels should make no assumptions about
+the input size or aspect ratio --- they are responsible for doing any
+resize/reshaping necessary (see docstring for the preprocess function).
+Output classes are always integers in the range [0, num_classes). Any mapping
+of these integers to semantic labels is to be handled outside of this class.
+
+Images are resized in the `preprocess` method. All of `preprocess`, `predict`,
+and `postprocess` should be reentrant.
+
+The `preprocess` method runs `image_resizer_fn` that returns resized_images and
+`true_image_shapes`. Since `image_resizer_fn` can pad the images with zeros,
+true_image_shapes indicate the slices that contain the image without padding.
+This is useful for padding images to be a fixed size for batching.
+
+The `postprocess` method uses the true image shapes to clip predictions that lie
+outside of images.
+
+By default, DetectionModels produce bounding box detections; However, we support
+a handful of auxiliary annotations associated with each bounding box, namely,
+instance masks and keypoints.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import abc
+import six
+import tensorflow as tf
+
+from object_detection.core import standard_fields as fields
+
+
+# If using a new enough version of TensorFlow, detection models should be a
+# tf module or keras model for tracking.
+try:
+ _BaseClass = tf.Module
+except AttributeError:
+ _BaseClass = object
+
+
+class DetectionModel(six.with_metaclass(abc.ABCMeta, _BaseClass)):
+ """Abstract base class for detection models.
+
+ Extends tf.Module to guarantee variable tracking.
+ """
+
+ def __init__(self, num_classes):
+ """Constructor.
+
+ Args:
+ num_classes: number of classes. Note that num_classes *does not* include
+ background categories that might be implicitly predicted in various
+ implementations.
+ """
+ self._num_classes = num_classes
+ self._groundtruth_lists = {}
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def groundtruth_lists(self, field):
+ """Access list of groundtruth tensors.
+
+ Args:
+ field: a string key, options are
+ fields.BoxListFields.{boxes,classes,masks,keypoints} or
+ fields.InputDataFields.is_annotated.
+
+ Returns:
+ a list of tensors holding groundtruth information (see also
+ provide_groundtruth function below), with one entry for each image in the
+ batch.
+ Raises:
+ RuntimeError: if the field has not been provided via provide_groundtruth.
+ """
+ if field not in self._groundtruth_lists:
+ raise RuntimeError('Groundtruth tensor {} has not been provided'.format(
+ field))
+ return self._groundtruth_lists[field]
+
+ def groundtruth_has_field(self, field):
+ """Determines whether the groundtruth includes the given field.
+
+ Args:
+ field: a string key, options are
+ fields.BoxListFields.{boxes,classes,masks,keypoints} or
+ fields.InputDataFields.is_annotated.
+
+ Returns:
+ True if the groundtruth includes the given field, False otherwise.
+ """
+ return field in self._groundtruth_lists
+
+ @abc.abstractmethod
+ def preprocess(self, inputs):
+ """Input preprocessing.
+
+ To be overridden by implementations.
+
+ This function is responsible for any scaling/shifting of input values that
+ is necessary prior to running the detector on an input image.
+ It is also responsible for any resizing, padding that might be necessary
+ as images are assumed to arrive in arbitrary sizes. While this function
+ could conceivably be part of the predict method (below), it is often
+ convenient to keep these separate --- for example, we may want to preprocess
+ on one device, place onto a queue, and let another device (e.g., the GPU)
+ handle prediction.
+
+ A few important notes about the preprocess function:
+ + We assume that this operation does not have any trainable variables nor
+ does it affect the groundtruth annotations in any way (thus data
+ augmentation operations such as random cropping should be performed
+ externally).
+ + There is no assumption that the batchsize in this function is the same as
+ the batch size in the predict function. In fact, we recommend calling the
+ preprocess function prior to calling any batching operations (which should
+ happen outside of the model) and thus assuming that batch sizes are equal
+ to 1 in the preprocess function.
+ + There is also no explicit assumption that the output resolutions
+ must be fixed across inputs --- this is to support "fully convolutional"
+ settings in which input images can have different shapes/resolutions.
+
+ Args:
+ inputs: a [batch, height_in, width_in, channels] float32 tensor
+ representing a batch of images with values between 0 and 255.0.
+
+ Returns:
+ preprocessed_inputs: a [batch, height_out, width_out, channels] float32
+ tensor representing a batch of images.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+ """
+ pass
+
+ @abc.abstractmethod
+ def predict(self, preprocessed_inputs, true_image_shapes):
+ """Predict prediction tensors from inputs tensor.
+
+ Outputs of this function can be passed to loss or postprocess functions.
+
+ Args:
+ preprocessed_inputs: a [batch, height, width, channels] float32 tensor
+ representing a batch of images.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+
+ Returns:
+ prediction_dict: a dictionary holding prediction tensors to be
+ passed to the Loss or Postprocess functions.
+ """
+ pass
+
+ @abc.abstractmethod
+ def postprocess(self, prediction_dict, true_image_shapes, **params):
+ """Convert predicted output tensors to final detections.
+
+ This stage typically performs a few things such as
+ * Non-Max Suppression to remove overlapping detection boxes.
+ * Score conversion and background class removal.
+
+ Outputs adhere to the following conventions:
+ * Classes are integers in [0, num_classes); background classes are removed
+ and the first non-background class is mapped to 0. If the model produces
+ class-agnostic detections, then no output is produced for classes.
+ * Boxes are to be interpreted as being in [y_min, x_min, y_max, x_max]
+ format and normalized relative to the image window.
+ * `num_detections` is provided for settings where detections are padded to a
+ fixed number of boxes.
+ * We do not specifically assume any kind of probabilistic interpretation
+ of the scores --- the only important thing is their relative ordering.
+ Thus implementations of the postprocess function are free to output
+ logits, probabilities, calibrated probabilities, or anything else.
+
+ Args:
+ prediction_dict: a dictionary holding prediction tensors.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+ **params: Additional keyword arguments for specific implementations of
+ DetectionModel.
+
+ Returns:
+ detections: a dictionary containing the following fields
+ detection_boxes: [batch, max_detections, 4]
+ detection_scores: [batch, max_detections]
+ detection_classes: [batch, max_detections]
+ (If a model is producing class-agnostic detections, this field may be
+ missing)
+ instance_masks: [batch, max_detections, image_height, image_width]
+ (optional)
+ keypoints: [batch, max_detections, num_keypoints, 2] (optional)
+ num_detections: [batch]
+
+ In addition to the above fields this stage also outputs the following
+ raw tensors:
+
+ raw_detection_boxes: [batch, total_detections, 4] tensor containing
+ all detection boxes from `prediction_dict` in the format
+ [ymin, xmin, ymax, xmax] and normalized co-ordinates.
+ raw_detection_scores: [batch, total_detections,
+ num_classes_with_background] tensor of class score logits for
+ raw detection boxes.
+ """
+ pass
+
+ @abc.abstractmethod
+ def loss(self, prediction_dict, true_image_shapes):
+ """Compute scalar loss tensors with respect to provided groundtruth.
+
+ Calling this function requires that groundtruth tensors have been
+ provided via the provide_groundtruth function.
+
+ Args:
+ prediction_dict: a dictionary holding predicted tensors
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+
+ Returns:
+ a dictionary mapping strings (loss names) to scalar tensors representing
+ loss values.
+ """
+ pass
+
+ def provide_groundtruth(self,
+ groundtruth_boxes_list,
+ groundtruth_classes_list,
+ groundtruth_masks_list=None,
+ groundtruth_keypoints_list=None,
+ groundtruth_weights_list=None,
+ groundtruth_confidences_list=None,
+ groundtruth_is_crowd_list=None,
+ is_annotated_list=None):
+ """Provide groundtruth tensors.
+
+ Args:
+ groundtruth_boxes_list: a list of 2-D tf.float32 tensors of shape
+ [num_boxes, 4] containing coordinates of the groundtruth boxes.
+ Groundtruth boxes are provided in [y_min, x_min, y_max, x_max]
+ format and assumed to be normalized and clipped
+ relative to the image window with y_min <= y_max and x_min <= x_max.
+ groundtruth_classes_list: a list of 2-D tf.float32 one-hot (or k-hot)
+ tensors of shape [num_boxes, num_classes] containing the class targets
+ with the 0th index assumed to map to the first non-background class.
+ groundtruth_masks_list: a list of 3-D tf.float32 tensors of
+ shape [num_boxes, height_in, width_in] containing instance
+ masks with values in {0, 1}. If None, no masks are provided.
+ Mask resolution `height_in`x`width_in` must agree with the resolution
+ of the input image tensor provided to the `preprocess` function.
+ groundtruth_keypoints_list: a list of 3-D tf.float32 tensors of
+ shape [num_boxes, num_keypoints, 2] containing keypoints.
+ Keypoints are assumed to be provided in normalized coordinates and
+ missing keypoints should be encoded as NaN.
+ groundtruth_weights_list: A list of 1-D tf.float32 tensors of shape
+ [num_boxes] containing weights for groundtruth boxes.
+ groundtruth_confidences_list: A list of 2-D tf.float32 tensors of shape
+ [num_boxes, num_classes] containing class confidences for groundtruth
+ boxes.
+ groundtruth_is_crowd_list: A list of 1-D tf.bool tensors of shape
+ [num_boxes] containing is_crowd annotations
+ is_annotated_list: A list of scalar tf.bool tensors indicating whether
+ images have been labeled or not.
+ """
+ self._groundtruth_lists[fields.BoxListFields.boxes] = groundtruth_boxes_list
+ self._groundtruth_lists[
+ fields.BoxListFields.classes] = groundtruth_classes_list
+ if groundtruth_weights_list:
+ self._groundtruth_lists[fields.BoxListFields.
+ weights] = groundtruth_weights_list
+ if groundtruth_confidences_list:
+ self._groundtruth_lists[fields.BoxListFields.
+ confidences] = groundtruth_confidences_list
+ if groundtruth_masks_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.masks] = groundtruth_masks_list
+ if groundtruth_keypoints_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.keypoints] = groundtruth_keypoints_list
+ if groundtruth_is_crowd_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.is_crowd] = groundtruth_is_crowd_list
+ if is_annotated_list:
+ self._groundtruth_lists[
+ fields.InputDataFields.is_annotated] = is_annotated_list
+
+ @abc.abstractmethod
+ def regularization_losses(self):
+ """Returns a list of regularization losses for this model.
+
+ Returns a list of regularization losses for this model that the estimator
+ needs to use during training/optimization.
+
+ Returns:
+ A list of regularization loss tensors.
+ """
+ pass
+
+ @abc.abstractmethod
+ def restore_map(self, fine_tune_checkpoint_type='detection'):
+ """Returns a map of variables to load from a foreign checkpoint.
+
+ Returns a map of variable names to load from a checkpoint to variables in
+ the model graph. This enables the model to initialize based on weights from
+ another task. For example, the feature extractor variables from a
+ classification model can be used to bootstrap training of an object
+ detector. When loading from an object detection model, the checkpoint model
+ should have the same parameters as this detection model with exception of
+ the num_classes parameter.
+
+ Args:
+ fine_tune_checkpoint_type: whether to restore from a full detection
+ checkpoint (with compatible variable names) or to restore from a
+ classification checkpoint for initialization prior to training.
+ Valid values: `detection`, `classification`. Default 'detection'.
+
+ Returns:
+ A dict mapping variable names (to load from a checkpoint) to variables in
+ the model graph.
+ """
+ pass
+
+ @abc.abstractmethod
+ def updates(self):
+ """Returns a list of update operators for this model.
+
+ Returns a list of update operators for this model that must be executed at
+ each training step. The estimator's train op needs to have a control
+ dependency on these updates.
+
+ Returns:
+ A list of update operators.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/multiclass_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/core/multiclass_nms_test.py
new file mode 100644
index 00000000..7cc01c65
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/multiclass_nms_test.py
@@ -0,0 +1,526 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for tensorflow_models.object_detection.core.post_processing."""
+import numpy as np
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.core import standard_fields as fields
+from object_detection.utils import test_case
+
+
+class MulticlassNonMaxSuppressionTest(test_case.TestCase):
+
+ def test_multiclass_nms_select_with_shared_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_shared_boxes_pad_to_max_output_size(self):
+ boxes = np.array([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], np.float32)
+ scores = np.array([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]], np.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 4
+ max_output_size = 5
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ def graph_fn(boxes, scores):
+ nms, num_valid_nms_boxes = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=max_output_size,
+ pad_to_max_output_size=True)
+ return [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes), num_valid_nms_boxes]
+
+ [nms_corners_output, nms_scores_output, nms_classes_output,
+ num_valid_nms_boxes] = self.execute(graph_fn, [boxes, scores])
+
+ self.assertEqual(num_valid_nms_boxes, 4)
+ self.assertAllClose(nms_corners_output[0:num_valid_nms_boxes],
+ exp_nms_corners)
+ self.assertAllClose(nms_scores_output[0:num_valid_nms_boxes],
+ exp_nms_scores)
+ self.assertAllClose(nms_classes_output[0:num_valid_nms_boxes],
+ exp_nms_classes)
+
+ def test_multiclass_nms_select_with_shared_boxes_given_keypoints(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ num_keypoints = 6
+ keypoints = tf.tile(
+ tf.reshape(tf.range(8), [8, 1, 1]),
+ [1, num_keypoints, 2])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_keypoints_tensor = tf.tile(
+ tf.reshape(tf.constant([3, 0, 6, 5], dtype=tf.float32), [4, 1, 1]),
+ [1, num_keypoints, 2])
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={fields.BoxListFields.keypoints: keypoints})
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_keypoints,
+ exp_nms_keypoints) = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.keypoints),
+ exp_nms_keypoints_tensor
+ ])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_keypoints, exp_nms_keypoints)
+
+ def test_multiclass_nms_with_shared_boxes_given_keypoint_heatmaps(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+
+ num_boxes = tf.shape(boxes)[0]
+ heatmap_height = 5
+ heatmap_width = 5
+ num_keypoints = 17
+ keypoint_heatmaps = tf.ones(
+ [num_boxes, heatmap_height, heatmap_width, num_keypoints],
+ dtype=tf.float32)
+
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_keypoint_heatmaps = np.ones(
+ (4, heatmap_height, heatmap_width, num_keypoints), dtype=np.float32)
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={
+ fields.BoxListFields.keypoint_heatmaps: keypoint_heatmaps
+ })
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_keypoint_heatmaps) = sess.run(
+ [nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.keypoint_heatmaps)])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_keypoint_heatmaps, exp_nms_keypoint_heatmaps)
+
+ def test_multiclass_nms_with_additional_fields(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+
+ coarse_boxes_key = 'coarse_boxes'
+ coarse_boxes = tf.constant([[0.1, 0.1, 1.1, 1.1],
+ [0.1, 0.2, 1.1, 1.2],
+ [0.1, -0.2, 1.1, 1.0],
+ [0.1, 10.1, 1.1, 11.1],
+ [0.1, 10.2, 1.1, 11.2],
+ [0.1, 100.1, 1.1, 101.1],
+ [0.1, 1000.1, 1.1, 1002.1],
+ [0.1, 1000.1, 1.1, 1002.2]], tf.float32)
+
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]], dtype=np.float32)
+
+ exp_nms_coarse_corners = np.array([[0.1, 10.1, 1.1, 11.1],
+ [0.1, 0.1, 1.1, 1.1],
+ [0.1, 1000.1, 1.1, 1002.1],
+ [0.1, 100.1, 1.1, 101.1]],
+ dtype=np.float32)
+
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={coarse_boxes_key: coarse_boxes})
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_coarse_corners) = sess.run(
+ [nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(coarse_boxes_key)])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_coarse_corners, exp_nms_coarse_corners)
+
+ def test_multiclass_nms_select_with_shared_boxes_given_masks(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ num_classes = 2
+ mask_height = 3
+ mask_width = 3
+ masks = tf.tile(
+ tf.reshape(tf.range(8), [8, 1, 1, 1]),
+ [1, num_classes, mask_height, mask_width])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_masks_tensor = tf.tile(
+ tf.reshape(tf.constant([3, 0, 6, 5], dtype=tf.float32), [4, 1, 1]),
+ [1, mask_height, mask_width])
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size, masks=masks)
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_masks,
+ exp_nms_masks) = sess.run([nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.masks),
+ exp_nms_masks_tensor])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_masks, exp_nms_masks)
+
+ def test_multiclass_nms_select_with_clip_window(self):
+ boxes = tf.constant([[[0, 0, 10, 10]],
+ [[1, 1, 11, 11]]], tf.float32)
+ scores = tf.constant([[.9], [.75]])
+ clip_window = tf.constant([5, 4, 8, 7], tf.float32)
+ score_thresh = 0.0
+ iou_thresh = 0.5
+ max_output_size = 100
+
+ exp_nms_corners = [[5, 4, 8, 7]]
+ exp_nms_scores = [.9]
+ exp_nms_classes = [0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ clip_window=clip_window)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_clip_window_change_coordinate_frame(self):
+ boxes = tf.constant([[[0, 0, 10, 10]],
+ [[1, 1, 11, 11]]], tf.float32)
+ scores = tf.constant([[.9], [.75]])
+ clip_window = tf.constant([5, 4, 8, 7], tf.float32)
+ score_thresh = 0.0
+ iou_thresh = 0.5
+ max_output_size = 100
+
+ exp_nms_corners = [[0, 0, 1, 1]]
+ exp_nms_scores = [.9]
+ exp_nms_classes = [0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ clip_window=clip_window,
+ change_coordinate_frame=True)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_per_class_cap(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 2
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002]]
+ exp_nms_scores = [.95, .9, .85]
+ exp_nms_classes = [0, 0, 1]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_size_per_class)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_total_cap(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 4
+ max_total_size = 2
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1]]
+ exp_nms_scores = [.95, .9]
+ exp_nms_classes = [0, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_size_per_class,
+ max_total_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_threshold_then_select_with_shared_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9], [.75], [.6], [.95], [.5], [.3], [.01], [.01]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_multiclass_nms_select_with_separate_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]],
+ tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 999, 2, 1004],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/post_processing.py b/Computer Vision/Plant_Disease_Detection_System/core/post_processing.py
new file mode 100644
index 00000000..90f1e06d
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/post_processing.py
@@ -0,0 +1,1223 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Post-processing operations on detected boxes."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import numpy as np
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import standard_fields as fields
+from object_detection.utils import shape_utils
+
+_NMS_TILE_SIZE = 512
+
+
+def batch_iou(boxes1, boxes2):
+ """Calculates the overlap between proposal and ground truth boxes.
+
+ Some `boxes2` may have been padded. The returned `iou` tensor for these
+ boxes will be -1.
+
+ Args:
+ boxes1: a tensor with a shape of [batch_size, N, 4]. N is the number of
+ proposals before groundtruth assignment. The last dimension is the pixel
+ coordinates in [ymin, xmin, ymax, xmax] form.
+ boxes2: a tensor with a shape of [batch_size, MAX_NUM_INSTANCES, 4]. This
+ tensor might have paddings with a negative value.
+
+ Returns:
+ iou: a tensor with as a shape of [batch_size, N, MAX_NUM_INSTANCES].
+ """
+ with tf.name_scope('BatchIOU'):
+ y1_min, x1_min, y1_max, x1_max = tf.split(
+ value=boxes1, num_or_size_splits=4, axis=2)
+ y2_min, x2_min, y2_max, x2_max = tf.split(
+ value=boxes2, num_or_size_splits=4, axis=2)
+
+ # Calculates the intersection area.
+ intersection_xmin = tf.maximum(x1_min, tf.transpose(x2_min, [0, 2, 1]))
+ intersection_xmax = tf.minimum(x1_max, tf.transpose(x2_max, [0, 2, 1]))
+ intersection_ymin = tf.maximum(y1_min, tf.transpose(y2_min, [0, 2, 1]))
+ intersection_ymax = tf.minimum(y1_max, tf.transpose(y2_max, [0, 2, 1]))
+ intersection_area = tf.maximum(
+ (intersection_xmax - intersection_xmin), 0) * tf.maximum(
+ (intersection_ymax - intersection_ymin), 0)
+
+ # Calculates the union area.
+ area1 = (y1_max - y1_min) * (x1_max - x1_min)
+ area2 = (y2_max - y2_min) * (x2_max - x2_min)
+ # Adds a small epsilon to avoid divide-by-zero.
+ union_area = area1 + tf.transpose(area2,
+ [0, 2, 1]) - intersection_area + 1e-8
+
+ # Calculates IoU.
+ iou = intersection_area / union_area
+
+ # Fills -1 for padded ground truth boxes.
+ padding_mask = tf.logical_and(
+ tf.less(intersection_xmax, 0), tf.less(intersection_ymax, 0))
+ iou = tf.where(padding_mask, -tf.ones_like(iou), iou)
+
+ return iou
+
+
+def _self_suppression(iou, iou_threshold, loop_condition, iou_sum):
+ """Bounding-boxes self-suppression loop body.
+
+ Args:
+ iou: A float Tensor with shape [1, num_boxes, max_num_instance]: IOUs.
+ iou_threshold: A scalar, representing IOU threshold.
+ loop_condition: The loop condition returned from last iteration.
+ iou_sum: iou_sum_new returned from last iteration.
+
+ Returns:
+ iou_suppressed: A float Tensor with shape [1, num_boxes, max_num_instance],
+ IOU after suppression.
+ iou_threshold: A scalar, representing IOU threshold.
+ loop_condition: Bool Tensor of shape [], the loop condition.
+ iou_sum_new: The new IOU sum.
+ """
+ del loop_condition
+ can_suppress_others = tf.cast(
+ tf.reshape(tf.reduce_max(iou, 1) <= iou_threshold, [1, -1, 1]), iou.dtype)
+ iou_suppressed = tf.reshape(
+ tf.cast(
+ tf.reduce_max(can_suppress_others * iou, 1) <= iou_threshold,
+ iou.dtype), [1, -1, 1]) * iou
+ iou_sum_new = tf.reduce_sum(iou_suppressed, [1, 2])
+ return [
+ iou_suppressed, iou_threshold,
+ tf.reduce_any(iou_sum - iou_sum_new > iou_threshold), iou_sum_new
+ ]
+
+
+def _cross_suppression(boxes, box_slice, iou_threshold, inner_idx):
+ """Bounding-boxes cross-suppression loop body.
+
+ Args:
+ boxes: A float Tensor of shape [1, anchors, 4], representing boxes.
+ box_slice: A float Tensor of shape [1, _NMS_TILE_SIZE, 4], the box tile
+ returned from last iteration
+ iou_threshold: A scalar, representing IOU threshold.
+ inner_idx: A scalar, representing inner index.
+
+ Returns:
+ boxes: A float Tensor of shape [1, anchors, 4], representing boxes.
+ ret_slice: A float Tensor of shape [1, _NMS_TILE_SIZE, 4], the box tile
+ after suppression
+ iou_threshold: A scalar, representing IOU threshold.
+ inner_idx: A scalar, inner index incremented.
+ """
+ new_slice = tf.slice(boxes, [0, inner_idx * _NMS_TILE_SIZE, 0],
+ [1, _NMS_TILE_SIZE, 4])
+ iou = batch_iou(new_slice, box_slice)
+ ret_slice = tf.expand_dims(
+ tf.cast(tf.reduce_all(iou < iou_threshold, [1]), box_slice.dtype),
+ 2) * box_slice
+ return boxes, ret_slice, iou_threshold, inner_idx + 1
+
+
+def _suppression_loop_body(boxes, iou_threshold, output_size, idx):
+ """Process boxes in the range [idx*_NMS_TILE_SIZE, (idx+1)*_NMS_TILE_SIZE).
+
+ Args:
+ boxes: a tensor with a shape of [1, anchors, 4].
+ iou_threshold: a float representing the threshold for deciding whether boxes
+ overlap too much with respect to IOU.
+ output_size: an int32 tensor of size [1]. Representing the number of
+ selected boxes.
+ idx: an integer scalar representing induction variable.
+
+ Returns:
+ boxes: updated boxes.
+ iou_threshold: pass down iou_threshold to the next iteration.
+ output_size: the updated output_size.
+ idx: the updated induction variable.
+ """
+ num_tiles = tf.shape(boxes)[1] // _NMS_TILE_SIZE
+
+ # Iterates over tiles that can possibly suppress the current tile.
+ box_slice = tf.slice(boxes, [0, idx * _NMS_TILE_SIZE, 0],
+ [1, _NMS_TILE_SIZE, 4])
+ _, box_slice, _, _ = tf.while_loop(
+ lambda _boxes, _box_slice, _threshold, inner_idx: inner_idx < idx,
+ _cross_suppression, [boxes, box_slice, iou_threshold,
+ tf.constant(0)])
+
+ # Iterates over the current tile to compute self-suppression.
+ iou = batch_iou(box_slice, box_slice)
+ mask = tf.expand_dims(
+ tf.reshape(tf.range(_NMS_TILE_SIZE), [1, -1]) > tf.reshape(
+ tf.range(_NMS_TILE_SIZE), [-1, 1]), 0)
+ iou *= tf.cast(tf.logical_and(mask, iou >= iou_threshold), iou.dtype)
+ suppressed_iou, _, _, _ = tf.while_loop(
+ lambda _iou, _threshold, loop_condition, _iou_sum: loop_condition,
+ _self_suppression,
+ [iou, iou_threshold,
+ tf.constant(True),
+ tf.reduce_sum(iou, [1, 2])])
+ suppressed_box = tf.reduce_sum(suppressed_iou, 1) > 0
+ box_slice *= tf.expand_dims(1.0 - tf.cast(suppressed_box, box_slice.dtype), 2)
+
+ # Uses box_slice to update the input boxes.
+ mask = tf.reshape(
+ tf.cast(tf.equal(tf.range(num_tiles), idx), boxes.dtype), [1, -1, 1, 1])
+ boxes = tf.tile(tf.expand_dims(box_slice, [1]),
+ [1, num_tiles, 1, 1]) * mask + tf.reshape(
+ boxes, [1, num_tiles, _NMS_TILE_SIZE, 4]) * (1 - mask)
+ boxes = tf.reshape(boxes, [1, -1, 4])
+
+ # Updates output_size.
+ output_size += tf.reduce_sum(
+ tf.cast(tf.reduce_any(box_slice > 0, [2]), tf.int32), [1])
+ return boxes, iou_threshold, output_size, idx + 1
+
+
+def partitioned_non_max_suppression_padded(boxes,
+ scores,
+ max_output_size,
+ iou_threshold=0.5,
+ score_threshold=float('-inf')):
+ """A tiled version of [`tf.image.non_max_suppression_padded`](https://www.tensorflow.org/api_docs/python/tf/image/non_max_suppression_padded).
+
+ The overall design of the algorithm is to handle boxes tile-by-tile:
+
+ boxes = boxes.pad_to_multiple_of(tile_size)
+ num_tiles = len(boxes) // tile_size
+ output_boxes = []
+ for i in range(num_tiles):
+ box_tile = boxes[i*tile_size : (i+1)*tile_size]
+ for j in range(i - 1):
+ suppressing_tile = boxes[j*tile_size : (j+1)*tile_size]
+ iou = batch_iou(box_tile, suppressing_tile)
+ # if the box is suppressed in iou, clear it to a dot
+ box_tile *= _update_boxes(iou)
+ # Iteratively handle the diagonal tile.
+ iou = _box_overlap(box_tile, box_tile)
+ iou_changed = True
+ while iou_changed:
+ # boxes that are not suppressed by anything else
+ suppressing_boxes = _get_suppressing_boxes(iou)
+ # boxes that are suppressed by suppressing_boxes
+ suppressed_boxes = _get_suppressed_boxes(iou, suppressing_boxes)
+ # clear iou to 0 for boxes that are suppressed, as they cannot be used
+ # to suppress other boxes any more
+ new_iou = _clear_iou(iou, suppressed_boxes)
+ iou_changed = (new_iou != iou)
+ iou = new_iou
+ # remaining boxes that can still suppress others, are selected boxes.
+ output_boxes.append(_get_suppressing_boxes(iou))
+ if len(output_boxes) >= max_output_size:
+ break
+
+ Args:
+ boxes: A 2-D float `Tensor` of shape `[num_boxes, 4]`.
+ scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single
+ score corresponding to each box (each row of boxes).
+ max_output_size: a scalar integer `Tensor` representing the maximum number
+ of boxes to be selected by non max suppression.
+ iou_threshold: a float representing the threshold for deciding whether boxes
+ overlap too much with respect to IOU.
+ score_threshold: A float representing the threshold for deciding when to
+ remove boxes based on score.
+
+ Returns:
+ selected_indices: a tensor of shape [anchors].
+ num_valid_boxes: a scalar int tensor.
+ nms_proposals: a tensor with a shape of [anchors, 4]. It has
+ same dtype as input boxes.
+ nms_scores: a tensor with a shape of [anchors]. It has same
+ dtype as input scores.
+ argsort_ids: a tensor of shape [anchors], mapping from input order of boxes
+ to output order of boxes.
+ """
+ num_boxes = tf.shape(boxes)[0]
+ pad = tf.cast(
+ tf.ceil(tf.cast(num_boxes, tf.float32) / _NMS_TILE_SIZE),
+ tf.int32) * _NMS_TILE_SIZE - num_boxes
+
+ scores, argsort_ids = tf.nn.top_k(scores, k=num_boxes, sorted=True)
+ boxes = tf.gather(boxes, argsort_ids)
+ num_boxes = tf.shape(boxes)[0]
+ num_boxes += pad
+ boxes = tf.pad(
+ tf.cast(boxes, tf.float32), [[0, pad], [0, 0]], constant_values=-1)
+ scores = tf.pad(tf.cast(scores, tf.float32), [[0, pad]])
+
+ # mask boxes to -1 by score threshold
+ scores_mask = tf.expand_dims(
+ tf.cast(scores > score_threshold, boxes.dtype), axis=1)
+ boxes = ((boxes + 1.) * scores_mask) - 1.
+
+ boxes = tf.expand_dims(boxes, axis=0)
+ scores = tf.expand_dims(scores, axis=0)
+
+ def _loop_cond(unused_boxes, unused_threshold, output_size, idx):
+ return tf.logical_and(
+ tf.reduce_min(output_size) < max_output_size,
+ idx < num_boxes // _NMS_TILE_SIZE)
+
+ selected_boxes, _, output_size, _ = tf.while_loop(
+ _loop_cond, _suppression_loop_body,
+ [boxes, iou_threshold,
+ tf.zeros([1], tf.int32),
+ tf.constant(0)])
+ idx = num_boxes - tf.cast(
+ tf.nn.top_k(
+ tf.cast(tf.reduce_any(selected_boxes > 0, [2]), tf.int32) *
+ tf.expand_dims(tf.range(num_boxes, 0, -1), 0), max_output_size)[0],
+ tf.int32)
+ idx = tf.minimum(idx, num_boxes - 1 - pad)
+ idx = tf.reshape(idx + tf.reshape(tf.range(1) * num_boxes, [-1, 1]), [-1])
+ num_valid_boxes = tf.reduce_sum(output_size)
+ return (idx, num_valid_boxes, tf.reshape(boxes, [-1, 4]),
+ tf.reshape(scores, [-1]), argsort_ids)
+
+
+def _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window):
+ """Validates boxes, scores and iou_thresh.
+
+ This function validates the boxes, scores, iou_thresh
+ and if change_coordinate_frame is True, clip_window must be specified.
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not
+ have a valid scores field.
+ """
+ if not 0 <= iou_thresh <= 1.0:
+ raise ValueError('iou_thresh must be between 0 and 1')
+ if scores.shape.ndims != 2:
+ raise ValueError('scores field must be of rank 2')
+ if shape_utils.get_dim_as_int(scores.shape[1]) is None:
+ raise ValueError('scores must have statically defined second ' 'dimension')
+ if boxes.shape.ndims != 3:
+ raise ValueError('boxes must be of rank 3.')
+ if not (shape_utils.get_dim_as_int(
+ boxes.shape[1]) == shape_utils.get_dim_as_int(scores.shape[1]) or
+ shape_utils.get_dim_as_int(boxes.shape[1]) == 1):
+ raise ValueError('second dimension of boxes must be either 1 or equal '
+ 'to the second dimension of scores')
+ if shape_utils.get_dim_as_int(boxes.shape[2]) != 4:
+ raise ValueError('last dimension of boxes must be of size 4.')
+ if change_coordinate_frame and clip_window is None:
+ raise ValueError('if change_coordinate_frame is True, then a clip_window'
+ 'must be specified.')
+
+
+def _clip_window_prune_boxes(sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame):
+ """Prune boxes with zero area.
+
+ Args:
+ sorted_boxes: A BoxList containing k detections.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ pad_to_max_output_size: flag indicating whether to pad to max output size or
+ not.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided).
+
+ Returns:
+ sorted_boxes: A BoxList containing k detections after pruning.
+ num_valid_nms_boxes_cumulative: Number of valid NMS boxes
+ """
+ sorted_boxes = box_list_ops.clip_to_window(
+ sorted_boxes,
+ clip_window,
+ filter_nonoverlapping=not pad_to_max_output_size)
+ # Set the scores of boxes with zero area to -1 to keep the default
+ # behaviour of pruning out zero area boxes.
+ sorted_boxes_size = tf.shape(sorted_boxes.get())[0]
+ non_zero_box_area = tf.cast(box_list_ops.area(sorted_boxes), tf.bool)
+ sorted_boxes_scores = tf.where(
+ non_zero_box_area, sorted_boxes.get_field(fields.BoxListFields.scores),
+ -1 * tf.ones(sorted_boxes_size))
+ sorted_boxes.add_field(fields.BoxListFields.scores, sorted_boxes_scores)
+ num_valid_nms_boxes_cumulative = tf.reduce_sum(
+ tf.cast(tf.greater_equal(sorted_boxes_scores, 0), tf.int32))
+ sorted_boxes = box_list_ops.sort_by_field(sorted_boxes,
+ fields.BoxListFields.scores)
+ if change_coordinate_frame:
+ sorted_boxes = box_list_ops.change_coordinate_frame(sorted_boxes,
+ clip_window)
+ return sorted_boxes, num_valid_nms_boxes_cumulative
+
+
+def multiclass_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ masks=None,
+ boundaries=None,
+ pad_to_max_output_size=False,
+ use_partitioned_nms=False,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None):
+ """Multi-class version of non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. It operates independently for each class for
+ which scores are provided (via the scores field of the input box_list),
+ pruning boxes with score less than a provided threshold prior to
+ applying NMS.
+
+ Please note that this operation is performed on *all* classes, therefore any
+ background classes should be removed prior to calling this function.
+
+ Selected boxes are guaranteed to be sorted in decreasing order by score (but
+ the sort is not guaranteed to be stable).
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_size_per_class: maximum number of retained boxes per class.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window
+ is provided)
+ masks: (optional) a [k, q, mask_height, mask_width] float32 tensor
+ containing box masks. `q` can be either number of classes or 1 depending
+ on whether a separate mask is predicted per class.
+ boundaries: (optional) a [k, q, boundary_height, boundary_width] float32
+ tensor containing box boundaries. `q` can be either number of classes or 1
+ depending on whether a separate boundary is predicted per class.
+ pad_to_max_output_size: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class`. Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose first dimensions are all of size `k`. After non-maximum
+ suppression, all tensors corresponding to the selected boxes will be
+ added to resulting BoxList.
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: name scope.
+
+ Returns:
+ A tuple of sorted_boxes and num_valid_nms_boxes. The sorted_boxes is a
+ BoxList holds M boxes with a rank-1 scores field representing
+ corresponding scores for each box with scores sorted in decreasing order
+ and a rank-1 classes field representing a class label for each box. The
+ num_valid_nms_boxes is a 0-D integer tensor representing the number of
+ valid elements in `BoxList`, with the valid elements appearing first.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not have
+ a valid scores field.
+ ValueError: if Soft NMS (tf.image.non_max_suppression_with_scores) is not
+ supported in the current TF version and `soft_nms_sigma` is nonzero.
+ """
+ _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window)
+ if pad_to_max_output_size and soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS (soft_nms_sigma != 0.0) is currently not '
+ 'supported when pad_to_max_output_size is True.')
+
+ with tf.name_scope(scope, 'MultiClassNonMaxSuppression'):
+ num_scores = tf.shape(scores)[0]
+ num_classes = shape_utils.get_dim_as_int(scores.get_shape()[1])
+
+ selected_boxes_list = []
+ num_valid_nms_boxes_cumulative = tf.constant(0)
+ per_class_boxes_list = tf.unstack(boxes, axis=1)
+ if masks is not None:
+ per_class_masks_list = tf.unstack(masks, axis=1)
+ if boundaries is not None:
+ per_class_boundaries_list = tf.unstack(boundaries, axis=1)
+ boxes_ids = (range(num_classes) if len(per_class_boxes_list) > 1
+ else [0] * num_classes)
+ for class_idx, boxes_idx in zip(range(num_classes), boxes_ids):
+ per_class_boxes = per_class_boxes_list[boxes_idx]
+ boxlist_and_class_scores = box_list.BoxList(per_class_boxes)
+ class_scores = tf.reshape(
+ tf.slice(scores, [0, class_idx], tf.stack([num_scores, 1])), [-1])
+
+ boxlist_and_class_scores.add_field(fields.BoxListFields.scores,
+ class_scores)
+ if masks is not None:
+ per_class_masks = per_class_masks_list[boxes_idx]
+ boxlist_and_class_scores.add_field(fields.BoxListFields.masks,
+ per_class_masks)
+ if boundaries is not None:
+ per_class_boundaries = per_class_boundaries_list[boxes_idx]
+ boxlist_and_class_scores.add_field(fields.BoxListFields.boundaries,
+ per_class_boundaries)
+ if additional_fields is not None:
+ for key, tensor in additional_fields.items():
+ boxlist_and_class_scores.add_field(key, tensor)
+
+ nms_result = None
+ selected_scores = None
+ if pad_to_max_output_size:
+ max_selection_size = max_size_per_class
+ if use_partitioned_nms:
+ (selected_indices, num_valid_nms_boxes,
+ boxlist_and_class_scores.data['boxes'],
+ boxlist_and_class_scores.data['scores'],
+ _) = partitioned_non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ else:
+ selected_indices, num_valid_nms_boxes = (
+ tf.image.non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(
+ fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_to_max_output_size=True))
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ else:
+ max_selection_size = tf.minimum(max_size_per_class,
+ boxlist_and_class_scores.num_boxes())
+ if (hasattr(tf.image, 'non_max_suppression_with_scores') and
+ tf.compat.forward_compatible(2019, 6, 6)):
+ (selected_indices, selected_scores
+ ) = tf.image.non_max_suppression_with_scores(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ soft_nms_sigma=soft_nms_sigma)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ selected_scores = tf.concat(
+ [selected_scores,
+ tf.zeros(max_selection_size-num_valid_nms_boxes,
+ tf.float32)], -1)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ else:
+ if soft_nms_sigma != 0:
+ raise ValueError('Soft NMS not supported in current TF version!')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ # Make the scores -1 for invalid boxes.
+ valid_nms_boxes_indices = tf.less(
+ tf.range(max_selection_size), num_valid_nms_boxes)
+
+ nms_result.add_field(
+ fields.BoxListFields.scores,
+ tf.where(valid_nms_boxes_indices,
+ selected_scores, -1*tf.ones(max_selection_size)))
+ num_valid_nms_boxes_cumulative += num_valid_nms_boxes
+
+ nms_result.add_field(
+ fields.BoxListFields.classes, (tf.zeros_like(
+ nms_result.get_field(fields.BoxListFields.scores)) + class_idx))
+ selected_boxes_list.append(nms_result)
+ selected_boxes = box_list_ops.concatenate(selected_boxes_list)
+ sorted_boxes = box_list_ops.sort_by_field(selected_boxes,
+ fields.BoxListFields.scores)
+ if clip_window is not None:
+ # When pad_to_max_output_size is False, it prunes the boxes with zero
+ # area.
+ sorted_boxes, num_valid_nms_boxes_cumulative = _clip_window_prune_boxes(
+ sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame)
+
+ if max_total_size:
+ max_total_size = tf.minimum(max_total_size, sorted_boxes.num_boxes())
+ sorted_boxes = box_list_ops.gather(sorted_boxes, tf.range(max_total_size))
+ num_valid_nms_boxes_cumulative = tf.where(
+ max_total_size > num_valid_nms_boxes_cumulative,
+ num_valid_nms_boxes_cumulative, max_total_size)
+ # Select only the valid boxes if pad_to_max_output_size is False.
+ if not pad_to_max_output_size:
+ sorted_boxes = box_list_ops.gather(
+ sorted_boxes, tf.range(num_valid_nms_boxes_cumulative))
+
+ return sorted_boxes, num_valid_nms_boxes_cumulative
+
+
+def class_agnostic_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_classes_per_detection=1,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ masks=None,
+ boundaries=None,
+ pad_to_max_output_size=False,
+ use_partitioned_nms=False,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None):
+ """Class-agnostic version of non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. It operates on all the boxes using
+ max scores across all classes for which scores are provided (via the scores
+ field of the input box_list), pruning boxes with score less than a provided
+ threshold prior to applying NMS.
+
+ Please note that this operation is performed in a class-agnostic way,
+ therefore any background classes should be removed prior to calling this
+ function.
+
+ Selected boxes are guaranteed to be sorted in decreasing order by score (but
+ the sort is not guaranteed to be stable).
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_classes_per_detection: maximum number of retained classes per detection
+ box in class-agnostic NMS.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ masks: (optional) a [k, q, mask_height, mask_width] float32 tensor
+ containing box masks. `q` can be either number of classes or 1 depending
+ on whether a separate mask is predicted per class.
+ boundaries: (optional) a [k, q, boundary_height, boundary_width] float32
+ tensor containing box boundaries. `q` can be either number of classes or 1
+ depending on whether a separate boundary is predicted per class.
+ pad_to_max_output_size: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class`. Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose first dimensions are all of size `k`. After non-maximum
+ suppression, all tensors corresponding to the selected boxes will be added
+ to resulting BoxList.
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: name scope.
+
+ Returns:
+ A tuple of sorted_boxes and num_valid_nms_boxes. The sorted_boxes is a
+ BoxList holds M boxes with a rank-1 scores field representing
+ corresponding scores for each box with scores sorted in decreasing order
+ and a rank-1 classes field representing a class label for each box. The
+ num_valid_nms_boxes is a 0-D integer tensor representing the number of
+ valid elements in `BoxList`, with the valid elements appearing first.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not have
+ a valid scores field or if non-zero soft_nms_sigma is provided when
+ pad_to_max_output_size is True.
+ """
+ _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window)
+ if pad_to_max_output_size and soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS (soft_nms_sigma != 0.0) is currently not '
+ 'supported when pad_to_max_output_size is True.')
+
+ if max_classes_per_detection > 1:
+ raise ValueError('Max classes per detection box >1 not supported.')
+ q = shape_utils.get_dim_as_int(boxes.shape[1])
+ if q > 1:
+ class_ids = tf.expand_dims(
+ tf.argmax(scores, axis=1, output_type=tf.int32), axis=1)
+ boxes = tf.batch_gather(boxes, class_ids)
+ if masks is not None:
+ masks = tf.batch_gather(masks, class_ids)
+ if boundaries is not None:
+ boundaries = tf.batch_gather(boundaries, class_ids)
+ boxes = tf.squeeze(boxes, axis=[1])
+ if masks is not None:
+ masks = tf.squeeze(masks, axis=[1])
+ if boundaries is not None:
+ boundaries = tf.squeeze(boundaries, axis=[1])
+
+ with tf.name_scope(scope, 'ClassAgnosticNonMaxSuppression'):
+ boxlist_and_class_scores = box_list.BoxList(boxes)
+ max_scores = tf.reduce_max(scores, axis=-1)
+ classes_with_max_scores = tf.argmax(scores, axis=-1)
+ boxlist_and_class_scores.add_field(fields.BoxListFields.scores, max_scores)
+ if masks is not None:
+ boxlist_and_class_scores.add_field(fields.BoxListFields.masks, masks)
+ if boundaries is not None:
+ boxlist_and_class_scores.add_field(fields.BoxListFields.boundaries,
+ boundaries)
+
+ if additional_fields is not None:
+ for key, tensor in additional_fields.items():
+ boxlist_and_class_scores.add_field(key, tensor)
+
+ nms_result = None
+ selected_scores = None
+ if pad_to_max_output_size:
+ max_selection_size = max_total_size
+ if use_partitioned_nms:
+ (selected_indices, num_valid_nms_boxes,
+ boxlist_and_class_scores.data['boxes'],
+ boxlist_and_class_scores.data['scores'],
+ argsort_ids) = partitioned_non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ classes_with_max_scores = tf.gather(classes_with_max_scores,
+ argsort_ids)
+ else:
+ selected_indices, num_valid_nms_boxes = (
+ tf.image.non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_to_max_output_size=True))
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ else:
+ max_selection_size = tf.minimum(max_total_size,
+ boxlist_and_class_scores.num_boxes())
+ if (hasattr(tf.image, 'non_max_suppression_with_scores') and
+ tf.compat.forward_compatible(2019, 6, 6)):
+ (selected_indices, selected_scores
+ ) = tf.image.non_max_suppression_with_scores(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ soft_nms_sigma=soft_nms_sigma)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat([
+ selected_indices,
+ tf.zeros(max_selection_size - num_valid_nms_boxes, tf.int32)
+ ], 0)
+ selected_scores = tf.concat(
+ [selected_scores,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.float32)], -1)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ else:
+ if soft_nms_sigma != 0:
+ raise ValueError('Soft NMS not supported in current TF version!')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ valid_nms_boxes_indices = tf.less(
+ tf.range(max_selection_size), num_valid_nms_boxes)
+ nms_result.add_field(
+ fields.BoxListFields.scores,
+ tf.where(valid_nms_boxes_indices,
+ selected_scores, -1*tf.ones(max_selection_size)))
+
+ selected_classes = tf.gather(classes_with_max_scores, selected_indices)
+ selected_classes = tf.cast(selected_classes, tf.float32)
+ nms_result.add_field(fields.BoxListFields.classes, selected_classes)
+ selected_boxes = nms_result
+ sorted_boxes = box_list_ops.sort_by_field(selected_boxes,
+ fields.BoxListFields.scores)
+
+ if clip_window is not None:
+ # When pad_to_max_output_size is False, it prunes the boxes with zero
+ # area.
+ sorted_boxes, num_valid_nms_boxes = _clip_window_prune_boxes(
+ sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame)
+
+ if max_total_size:
+ max_total_size = tf.minimum(max_total_size, sorted_boxes.num_boxes())
+ sorted_boxes = box_list_ops.gather(sorted_boxes, tf.range(max_total_size))
+ num_valid_nms_boxes = tf.where(max_total_size > num_valid_nms_boxes,
+ num_valid_nms_boxes, max_total_size)
+ # Select only the valid boxes if pad_to_max_output_size is False.
+ if not pad_to_max_output_size:
+ sorted_boxes = box_list_ops.gather(sorted_boxes,
+ tf.range(num_valid_nms_boxes))
+
+ return sorted_boxes, num_valid_nms_boxes
+
+
+def batch_multiclass_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ num_valid_boxes=None,
+ masks=None,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None,
+ use_static_shapes=False,
+ use_partitioned_nms=False,
+ parallel_iterations=32,
+ use_class_agnostic_nms=False,
+ max_classes_per_detection=1,
+ use_dynamic_map_fn=False,
+ use_combined_nms=False):
+ """Multi-class version of non maximum suppression that operates on a batch.
+
+ This op is similar to `multiclass_non_max_suppression` but operates on a batch
+ of boxes and scores. See documentation for `multiclass_non_max_suppression`
+ for details.
+
+ Args:
+ boxes: A [batch_size, num_anchors, q, 4] float32 tensor containing
+ detections. If `q` is 1 then same boxes are used for all classes
+ otherwise, if `q` is equal to number of classes, class-specific boxes are
+ used.
+ scores: A [batch_size, num_anchors, num_classes] float32 tensor containing
+ the scores for each of the `num_anchors` detections. The scores have to be
+ non-negative when use_static_shapes is set True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_size_per_class: maximum number of retained boxes per class.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of shape [batch_size, 4] where each entry is
+ of the form [y_min, x_min, y_max, x_max] representing the window to clip
+ boxes to before performing non-max suppression. This argument can also be
+ a tensor of shape [4] in which case, the same clip window is applied to
+ all images in the batch. If clip_widow is None, all boxes are used to
+ perform non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ num_valid_boxes: (optional) a Tensor of type `int32`. A 1-D tensor of shape
+ [batch_size] representing the number of valid boxes to be considered for
+ each image in the batch. This parameter allows for ignoring zero
+ paddings.
+ masks: (optional) a [batch_size, num_anchors, q, mask_height, mask_width]
+ float32 tensor containing box masks. `q` can be either number of classes
+ or 1 depending on whether a separate mask is predicted per class.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose dimensions are [batch_size, num_anchors, ...].
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: tf scope name.
+ use_static_shapes: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class` and it doesn't clip boxes to max_total_size.
+ Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ parallel_iterations: (optional) number of batch items to process in
+ parallel.
+ use_class_agnostic_nms: If true, this uses class-agnostic non max
+ suppression
+ max_classes_per_detection: Maximum number of retained classes per detection
+ box in class-agnostic NMS.
+ use_dynamic_map_fn: If true, images in the batch will be processed within a
+ dynamic loop. Otherwise, a static loop will be used if possible.
+ use_combined_nms: If true, it uses tf.image.combined_non_max_suppression (
+ multi-class version of NMS that operates on a batch).
+ It greedily selects a subset of detection bounding boxes, pruning away
+ boxes that have high IOU (intersection over union) overlap (> thresh) with
+ already selected boxes. It operates independently for each batch.
+ Within each batch, it operates independently for each class for which
+ scores are provided (via the scores field of the input box_list),
+ pruning boxes with score less than a provided threshold prior to applying
+ NMS. This operation is performed on *all* batches and *all* classes
+ in the batch, therefore any background classes should be removed prior to
+ calling this function.
+ Masks and additional fields are not supported.
+ See argument checks in the code below for unsupported arguments.
+
+ Returns:
+ 'nmsed_boxes': A [batch_size, max_detections, 4] float32 tensor
+ containing the non-max suppressed boxes.
+ 'nmsed_scores': A [batch_size, max_detections] float32 tensor containing
+ the scores for the boxes.
+ 'nmsed_classes': A [batch_size, max_detections] float32 tensor
+ containing the class for boxes.
+ 'nmsed_masks': (optional) a
+ [batch_size, max_detections, mask_height, mask_width] float32 tensor
+ containing masks for each selected box. This is set to None if input
+ `masks` is None.
+ 'nmsed_additional_fields': (optional) a dictionary of
+ [batch_size, max_detections, ...] float32 tensors corresponding to the
+ tensors specified in the input `additional_fields`. This is not returned
+ if input `additional_fields` is None.
+ 'num_detections': A [batch_size] int32 tensor indicating the number of
+ valid detections per batch item. Only the top num_detections[i] entries in
+ nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
+ entries are zero paddings.
+
+ Raises:
+ ValueError: if `q` in boxes.shape is not 1 or not equal to number of
+ classes as inferred from scores.shape.
+ """
+ if use_combined_nms:
+ if change_coordinate_frame:
+ raise ValueError(
+ 'change_coordinate_frame (normalizing coordinates'
+ ' relative to clip_window) is not supported by combined_nms.')
+ if num_valid_boxes is not None:
+ raise ValueError('num_valid_boxes is not supported by combined_nms.')
+ if masks is not None:
+ raise ValueError('masks is not supported by combined_nms.')
+ if soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS is not supported by combined_nms.')
+ if use_class_agnostic_nms:
+ raise ValueError('class-agnostic NMS is not supported by combined_nms.')
+ if clip_window is not None:
+ tf.compat.v1.logging.warning(
+ 'clip_window is not supported by combined_nms unless it is'
+ ' [0. 0. 1. 1.] for each image.')
+ if additional_fields is not None:
+ tf.compat.v1.logging.warning(
+ 'additional_fields is not supported by combined_nms.')
+ if parallel_iterations != 32:
+ tf.compat.v1.logging.warning(
+ 'Number of batch items to be processed in parallel is'
+ ' not configurable by combined_nms.')
+ if max_classes_per_detection > 1:
+ tf.compat.v1.logging.warning(
+ 'max_classes_per_detection is not configurable by combined_nms.')
+
+ with tf.name_scope(scope, 'CombinedNonMaxSuppression'):
+ (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_num_detections) = tf.image.combined_non_max_suppression(
+ boxes=boxes,
+ scores=scores,
+ max_output_size_per_class=max_size_per_class,
+ max_total_size=max_total_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_per_class=use_static_shapes)
+ # Not supported by combined_non_max_suppression.
+ batch_nmsed_masks = None
+ # Not supported by combined_non_max_suppression.
+ batch_nmsed_additional_fields = None
+ return (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_nmsed_masks, batch_nmsed_additional_fields,
+ batch_num_detections)
+
+ q = shape_utils.get_dim_as_int(boxes.shape[2])
+ num_classes = shape_utils.get_dim_as_int(scores.shape[2])
+ if q != 1 and q != num_classes:
+ raise ValueError('third dimension of boxes must be either 1 or equal '
+ 'to the third dimension of scores.')
+ if change_coordinate_frame and clip_window is None:
+ raise ValueError('if change_coordinate_frame is True, then a clip_window'
+ 'must be specified.')
+ original_masks = masks
+
+ # Create ordered dictionary using the sorted keys from
+ # additional fields to ensure getting the same key value assignment
+ # in _single_image_nms_fn(). The dictionary is thus a sorted version of
+ # additional_fields.
+ if additional_fields is None:
+ ordered_additional_fields = {}
+ else:
+ ordered_additional_fields = collections.OrderedDict(
+ sorted(additional_fields.items(), key=lambda item: item[0]))
+ del additional_fields
+ with tf.name_scope(scope, 'BatchMultiClassNonMaxSuppression'):
+ boxes_shape = boxes.shape
+ batch_size = shape_utils.get_dim_as_int(boxes_shape[0])
+ num_anchors = shape_utils.get_dim_as_int(boxes_shape[1])
+
+ if batch_size is None:
+ batch_size = tf.shape(boxes)[0]
+ if num_anchors is None:
+ num_anchors = tf.shape(boxes)[1]
+
+ # If num valid boxes aren't provided, create one and mark all boxes as
+ # valid.
+ if num_valid_boxes is None:
+ num_valid_boxes = tf.ones([batch_size], dtype=tf.int32) * num_anchors
+
+ # If masks aren't provided, create dummy masks so we can only have one copy
+ # of _single_image_nms_fn and discard the dummy masks after map_fn.
+ if masks is None:
+ masks_shape = tf.stack([batch_size, num_anchors, q, 1, 1])
+ masks = tf.zeros(masks_shape)
+
+ if clip_window is None:
+ clip_window = tf.stack([
+ tf.reduce_min(boxes[:, :, :, 0]),
+ tf.reduce_min(boxes[:, :, :, 1]),
+ tf.reduce_max(boxes[:, :, :, 2]),
+ tf.reduce_max(boxes[:, :, :, 3])
+ ])
+ if clip_window.shape.ndims == 1:
+ clip_window = tf.tile(tf.expand_dims(clip_window, 0), [batch_size, 1])
+
+ def _single_image_nms_fn(args):
+ """Runs NMS on a single image and returns padded output.
+
+ Args:
+ args: A list of tensors consisting of the following:
+ per_image_boxes - A [num_anchors, q, 4] float32 tensor containing
+ detections. If `q` is 1 then same boxes are used for all classes
+ otherwise, if `q` is equal to number of classes, class-specific
+ boxes are used.
+ per_image_scores - A [num_anchors, num_classes] float32 tensor
+ containing the scores for each of the `num_anchors` detections.
+ per_image_masks - A [num_anchors, q, mask_height, mask_width] float32
+ tensor containing box masks. `q` can be either number of classes
+ or 1 depending on whether a separate mask is predicted per class.
+ per_image_clip_window - A 1D float32 tensor of the form
+ [ymin, xmin, ymax, xmax] representing the window to clip the boxes
+ to.
+ per_image_additional_fields - (optional) A variable number of float32
+ tensors each with size [num_anchors, ...].
+ per_image_num_valid_boxes - A tensor of type `int32`. A 1-D tensor of
+ shape [batch_size] representing the number of valid boxes to be
+ considered for each image in the batch. This parameter allows for
+ ignoring zero paddings.
+
+ Returns:
+ 'nmsed_boxes': A [max_detections, 4] float32 tensor containing the
+ non-max suppressed boxes.
+ 'nmsed_scores': A [max_detections] float32 tensor containing the scores
+ for the boxes.
+ 'nmsed_classes': A [max_detections] float32 tensor containing the class
+ for boxes.
+ 'nmsed_masks': (optional) a [max_detections, mask_height, mask_width]
+ float32 tensor containing masks for each selected box. This is set to
+ None if input `masks` is None.
+ 'nmsed_additional_fields': (optional) A variable number of float32
+ tensors each with size [max_detections, ...] corresponding to the
+ input `per_image_additional_fields`.
+ 'num_detections': A [batch_size] int32 tensor indicating the number of
+ valid detections per batch item. Only the top num_detections[i]
+ entries in nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The
+ rest of the entries are zero paddings.
+ """
+ per_image_boxes = args[0]
+ per_image_scores = args[1]
+ per_image_masks = args[2]
+ per_image_clip_window = args[3]
+ # Make sure that the order of elements passed in args is aligned with
+ # the iteration order of ordered_additional_fields
+ per_image_additional_fields = {
+ key: value
+ for key, value in zip(ordered_additional_fields, args[4:-1])
+ }
+ per_image_num_valid_boxes = args[-1]
+ if use_static_shapes:
+ total_proposals = tf.shape(per_image_scores)
+ per_image_scores = tf.where(
+ tf.less(tf.range(total_proposals[0]), per_image_num_valid_boxes),
+ per_image_scores,
+ tf.fill(total_proposals, np.finfo('float32').min))
+ else:
+ per_image_boxes = tf.reshape(
+ tf.slice(per_image_boxes, 3 * [0],
+ tf.stack([per_image_num_valid_boxes, -1, -1])), [-1, q, 4])
+ per_image_scores = tf.reshape(
+ tf.slice(per_image_scores, [0, 0],
+ tf.stack([per_image_num_valid_boxes, -1])),
+ [-1, num_classes])
+ per_image_masks = tf.reshape(
+ tf.slice(per_image_masks, 4 * [0],
+ tf.stack([per_image_num_valid_boxes, -1, -1, -1])),
+ [-1, q, shape_utils.get_dim_as_int(per_image_masks.shape[2]),
+ shape_utils.get_dim_as_int(per_image_masks.shape[3])])
+ if per_image_additional_fields is not None:
+ for key, tensor in per_image_additional_fields.items():
+ additional_field_shape = tensor.get_shape()
+ additional_field_dim = len(additional_field_shape)
+ per_image_additional_fields[key] = tf.reshape(
+ tf.slice(
+ per_image_additional_fields[key],
+ additional_field_dim * [0],
+ tf.stack([per_image_num_valid_boxes] +
+ (additional_field_dim - 1) * [-1])), [-1] + [
+ shape_utils.get_dim_as_int(dim)
+ for dim in additional_field_shape[1:]
+ ])
+ if use_class_agnostic_nms:
+ nmsed_boxlist, num_valid_nms_boxes = class_agnostic_non_max_suppression(
+ per_image_boxes,
+ per_image_scores,
+ score_thresh,
+ iou_thresh,
+ max_classes_per_detection,
+ max_total_size,
+ clip_window=per_image_clip_window,
+ change_coordinate_frame=change_coordinate_frame,
+ masks=per_image_masks,
+ pad_to_max_output_size=use_static_shapes,
+ use_partitioned_nms=use_partitioned_nms,
+ additional_fields=per_image_additional_fields,
+ soft_nms_sigma=soft_nms_sigma)
+ else:
+ nmsed_boxlist, num_valid_nms_boxes = multiclass_non_max_suppression(
+ per_image_boxes,
+ per_image_scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size,
+ clip_window=per_image_clip_window,
+ change_coordinate_frame=change_coordinate_frame,
+ masks=per_image_masks,
+ pad_to_max_output_size=use_static_shapes,
+ use_partitioned_nms=use_partitioned_nms,
+ additional_fields=per_image_additional_fields,
+ soft_nms_sigma=soft_nms_sigma)
+
+ if not use_static_shapes:
+ nmsed_boxlist = box_list_ops.pad_or_clip_box_list(
+ nmsed_boxlist, max_total_size)
+ num_detections = num_valid_nms_boxes
+ nmsed_boxes = nmsed_boxlist.get()
+ nmsed_scores = nmsed_boxlist.get_field(fields.BoxListFields.scores)
+ nmsed_classes = nmsed_boxlist.get_field(fields.BoxListFields.classes)
+ nmsed_masks = nmsed_boxlist.get_field(fields.BoxListFields.masks)
+ nmsed_additional_fields = []
+ # Sorting is needed here to ensure that the values stored in
+ # nmsed_additional_fields are always kept in the same order
+ # across different execution runs.
+ for key in sorted(per_image_additional_fields.keys()):
+ nmsed_additional_fields.append(nmsed_boxlist.get_field(key))
+ return ([nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks] +
+ nmsed_additional_fields + [num_detections])
+
+ num_additional_fields = 0
+ if ordered_additional_fields:
+ num_additional_fields = len(ordered_additional_fields)
+ num_nmsed_outputs = 4 + num_additional_fields
+
+ if use_dynamic_map_fn:
+ map_fn = tf.map_fn
+ else:
+ map_fn = shape_utils.static_or_dynamic_map_fn
+
+ batch_outputs = map_fn(
+ _single_image_nms_fn,
+ elems=([boxes, scores, masks, clip_window] +
+ list(ordered_additional_fields.values()) + [num_valid_boxes]),
+ dtype=(num_nmsed_outputs * [tf.float32] + [tf.int32]),
+ parallel_iterations=parallel_iterations)
+
+ batch_nmsed_boxes = batch_outputs[0]
+ batch_nmsed_scores = batch_outputs[1]
+ batch_nmsed_classes = batch_outputs[2]
+ batch_nmsed_masks = batch_outputs[3]
+ batch_nmsed_values = batch_outputs[4:-1]
+
+ batch_nmsed_additional_fields = {}
+ if num_additional_fields > 0:
+ # Sort the keys to ensure arranging elements in same order as
+ # in _single_image_nms_fn.
+ batch_nmsed_keys = list(ordered_additional_fields.keys())
+ for i in range(len(batch_nmsed_keys)):
+ batch_nmsed_additional_fields[
+ batch_nmsed_keys[i]] = batch_nmsed_values[i]
+
+ batch_num_detections = batch_outputs[-1]
+
+ if original_masks is None:
+ batch_nmsed_masks = None
+
+ if not ordered_additional_fields:
+ batch_nmsed_additional_fields = None
+
+ return (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_nmsed_masks, batch_nmsed_additional_fields,
+ batch_num_detections)
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/prefetcher.py b/Computer Vision/Plant_Disease_Detection_System/core/prefetcher.py
new file mode 100644
index 00000000..9bb7d658
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/prefetcher.py
@@ -0,0 +1,61 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Provides functions to prefetch tensors to feed into models."""
+import tensorflow as tf
+
+
+def prefetch(tensor_dict, capacity):
+ """Creates a prefetch queue for tensors.
+
+ Creates a FIFO queue to asynchronously enqueue tensor_dicts and returns a
+ dequeue op that evaluates to a tensor_dict. This function is useful in
+ prefetching preprocessed tensors so that the data is readily available for
+ consumers.
+
+ Example input pipeline when you don't need batching:
+ ----------------------------------------------------
+ key, string_tensor = slim.parallel_reader.parallel_read(...)
+ tensor_dict = decoder.decode(string_tensor)
+ tensor_dict = preprocessor.preprocess(tensor_dict, ...)
+ prefetch_queue = prefetcher.prefetch(tensor_dict, capacity=20)
+ tensor_dict = prefetch_queue.dequeue()
+ outputs = Model(tensor_dict)
+ ...
+ ----------------------------------------------------
+
+ For input pipelines with batching, refer to core/batcher.py
+
+ Args:
+ tensor_dict: a dictionary of tensors to prefetch.
+ capacity: the size of the prefetch queue.
+
+ Returns:
+ a FIFO prefetcher queue
+ """
+ names = list(tensor_dict.keys())
+ dtypes = [t.dtype for t in tensor_dict.values()]
+ shapes = [t.get_shape() for t in tensor_dict.values()]
+ prefetch_queue = tf.PaddingFIFOQueue(capacity, dtypes=dtypes,
+ shapes=shapes,
+ names=names,
+ name='prefetch_queue')
+ enqueue_op = prefetch_queue.enqueue(tensor_dict)
+ tf.train.queue_runner.add_queue_runner(tf.train.queue_runner.QueueRunner(
+ prefetch_queue, [enqueue_op]))
+ tf.summary.scalar(
+ 'queue/%s/fraction_of_%d_full' % (prefetch_queue.name, capacity),
+ tf.cast(prefetch_queue.size(), dtype=tf.float32) * (1. / capacity))
+ return prefetch_queue
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/prefetcher_test.py b/Computer Vision/Plant_Disease_Detection_System/core/prefetcher_test.py
new file mode 100644
index 00000000..83782d35
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/prefetcher_test.py
@@ -0,0 +1,106 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.prefetcher."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import prefetcher
+
+slim = tf.contrib.slim
+
+
+class PrefetcherTest(tf.test.TestCase):
+
+ def test_prefetch_tensors_with_fully_defined_shapes(self):
+ with self.test_session() as sess:
+ batch_size = 10
+ image_size = 32
+ num_batches = 5
+ examples = tf.Variable(tf.constant(0, dtype=tf.int64))
+ counter = examples.count_up_to(num_batches)
+ image = tf.random_normal([batch_size, image_size,
+ image_size, 3],
+ dtype=tf.float32,
+ name='images')
+ label = tf.random_uniform([batch_size, 1], 0, 10,
+ dtype=tf.int32, name='labels')
+
+ prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
+ 'image': image,
+ 'label': label},
+ capacity=100)
+ tensor_dict = prefetch_queue.dequeue()
+
+ self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
+ [batch_size, image_size, image_size, 3])
+ self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
+ [batch_size, 1])
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ for _ in range(num_batches):
+ results = sess.run(tensor_dict)
+ self.assertEquals(results['image'].shape,
+ (batch_size, image_size, image_size, 3))
+ self.assertEquals(results['label'].shape, (batch_size, 1))
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(tensor_dict)
+
+ def test_prefetch_tensors_with_partially_defined_shapes(self):
+ with self.test_session() as sess:
+ batch_size = 10
+ image_size = 32
+ num_batches = 5
+ examples = tf.Variable(tf.constant(0, dtype=tf.int64))
+ counter = examples.count_up_to(num_batches)
+ image = tf.random_normal([batch_size,
+ tf.Variable(image_size),
+ tf.Variable(image_size), 3],
+ dtype=tf.float32,
+ name='image')
+ image.set_shape([batch_size, None, None, 3])
+ label = tf.random_uniform([batch_size, tf.Variable(1)], 0,
+ 10, dtype=tf.int32, name='label')
+ label.set_shape([batch_size, None])
+
+ prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
+ 'image': image,
+ 'label': label},
+ capacity=100)
+ tensor_dict = prefetch_queue.dequeue()
+
+ self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
+ [batch_size, None, None, 3])
+ self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
+ [batch_size, None])
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ for _ in range(num_batches):
+ results = sess.run(tensor_dict)
+ self.assertEquals(results['image'].shape,
+ (batch_size, image_size, image_size, 3))
+ self.assertEquals(results['label'].shape, (batch_size, 1))
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(tensor_dict)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/preprocessor.py b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor.py
new file mode 100644
index 00000000..1c74a585
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor.py
@@ -0,0 +1,4008 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Preprocess images and bounding boxes for detection.
+
+We perform two sets of operations in preprocessing stage:
+(a) operations that are applied to both training and testing data,
+(b) operations that are applied only to training data for the purpose of
+ data augmentation.
+
+A preprocessing function receives a set of inputs,
+e.g. an image and bounding boxes,
+performs an operation on them, and returns them.
+Some examples are: randomly cropping the image, randomly mirroring the image,
+ randomly changing the brightness, contrast, hue and
+ randomly jittering the bounding boxes.
+
+The preprocess function receives a tensor_dict which is a dictionary that maps
+different field names to their tensors. For example,
+tensor_dict[fields.InputDataFields.image] holds the image tensor.
+The image is a rank 4 tensor: [1, height, width, channels] with
+dtype=tf.float32. The groundtruth_boxes is a rank 2 tensor: [N, 4] where
+in each row there is a box with [ymin xmin ymax xmax].
+Boxes are in normalized coordinates meaning
+their coordinate values range in [0, 1]
+
+To preprocess multiple images with the same operations in cases where
+nondeterministic operations are used, a preprocessor_cache.PreprocessorCache
+object can be passed into the preprocess function or individual operations.
+All nondeterministic operations except random_jitter_boxes support caching.
+E.g.
+Let tensor_dict{1,2,3,4,5} be copies of the same inputs.
+Let preprocess_options contain nondeterministic operation(s) excluding
+random_jitter_boxes.
+
+cache1 = preprocessor_cache.PreprocessorCache()
+cache2 = preprocessor_cache.PreprocessorCache()
+a = preprocess(tensor_dict1, preprocess_options, preprocess_vars_cache=cache1)
+b = preprocess(tensor_dict2, preprocess_options, preprocess_vars_cache=cache1)
+c = preprocess(tensor_dict3, preprocess_options, preprocess_vars_cache=cache2)
+d = preprocess(tensor_dict4, preprocess_options, preprocess_vars_cache=cache2)
+e = preprocess(tensor_dict5, preprocess_options)
+
+Then correspondings tensors of object pairs (a,b) and (c,d)
+are guaranteed to be equal element-wise, but the equality of any other object
+pair cannot be determined.
+
+Important Note: In tensor_dict, images is a rank 4 tensor, but preprocessing
+functions receive a rank 3 tensor for processing the image. Thus, inside the
+preprocess function we squeeze the image to become a rank 3 tensor and then
+we pass it to the functions. At the end of the preprocess we expand the image
+back to rank 4.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import functools
+import inspect
+import sys
+
+import six
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from tensorflow.python.ops import control_flow_ops
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import keypoint_ops
+from object_detection.core import preprocessor_cache
+from object_detection.core import standard_fields as fields
+from object_detection.utils import autoaugment_utils
+from object_detection.utils import patch_ops
+from object_detection.utils import shape_utils
+
+
+def _apply_with_random_selector(x,
+ func,
+ num_cases,
+ preprocess_vars_cache=None,
+ key=''):
+ """Computes func(x, sel), with sel sampled from [0...num_cases-1].
+
+ If both preprocess_vars_cache AND key are the same between two calls, sel will
+ be the same value in both calls.
+
+ Args:
+ x: input Tensor.
+ func: Python function to apply.
+ num_cases: Python int32, number of cases to sample sel from.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: variable identifier for preprocess_vars_cache.
+
+ Returns:
+ The result of func(x, sel), where func receives the value of the
+ selector as a python integer, but sel is sampled dynamically.
+ """
+ generator_func = functools.partial(
+ tf.random_uniform, [], maxval=num_cases, dtype=tf.int32)
+ rand_sel = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.SELECTOR,
+ preprocess_vars_cache, key)
+
+ # Pass the real x only to one of the func calls.
+ return control_flow_ops.merge([func(
+ control_flow_ops.switch(x, tf.equal(rand_sel, case))[1], case)
+ for case in range(num_cases)])[0]
+
+
+def _apply_with_random_selector_tuples(x,
+ func,
+ num_cases,
+ preprocess_vars_cache=None,
+ key=''):
+ """Computes func(x, sel), with sel sampled from [0...num_cases-1].
+
+ If both preprocess_vars_cache AND key are the same between two calls, sel will
+ be the same value in both calls.
+
+ Args:
+ x: A tuple of input tensors.
+ func: Python function to apply.
+ num_cases: Python int32, number of cases to sample sel from.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: variable identifier for preprocess_vars_cache.
+
+ Returns:
+ The result of func(x, sel), where func receives the value of the
+ selector as a python integer, but sel is sampled dynamically.
+ """
+ num_inputs = len(x)
+ generator_func = functools.partial(
+ tf.random_uniform, [], maxval=num_cases, dtype=tf.int32)
+ rand_sel = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.SELECTOR_TUPLES,
+ preprocess_vars_cache, key)
+
+ # Pass the real x only to one of the func calls.
+ tuples = [list() for t in x]
+ for case in range(num_cases):
+ new_x = [control_flow_ops.switch(t, tf.equal(rand_sel, case))[1] for t in x]
+ output = func(tuple(new_x), case)
+ for j in range(num_inputs):
+ tuples[j].append(output[j])
+
+ for i in range(num_inputs):
+ tuples[i] = control_flow_ops.merge(tuples[i])[0]
+ return tuple(tuples)
+
+
+def _get_or_create_preprocess_rand_vars(generator_func,
+ function_id,
+ preprocess_vars_cache,
+ key=''):
+ """Returns a tensor stored in preprocess_vars_cache or using generator_func.
+
+ If the tensor was previously generated and appears in the PreprocessorCache,
+ the previously generated tensor will be returned. Otherwise, a new tensor
+ is generated using generator_func and stored in the cache.
+
+ Args:
+ generator_func: A 0-argument function that generates a tensor.
+ function_id: identifier for the preprocessing function used.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: identifier for the variable stored.
+ Returns:
+ The generated tensor.
+ """
+ if preprocess_vars_cache is not None:
+ var = preprocess_vars_cache.get(function_id, key)
+ if var is None:
+ var = generator_func()
+ preprocess_vars_cache.update(function_id, key, var)
+ else:
+ var = generator_func()
+ return var
+
+
+def _random_integer(minval, maxval, seed):
+ """Returns a random 0-D tensor between minval and maxval.
+
+ Args:
+ minval: minimum value of the random tensor.
+ maxval: maximum value of the random tensor.
+ seed: random seed.
+
+ Returns:
+ A random 0-D tensor between minval and maxval.
+ """
+ return tf.random_uniform(
+ [], minval=minval, maxval=maxval, dtype=tf.int32, seed=seed)
+
+
+# TODO(mttang): This method is needed because the current
+# tf.image.rgb_to_grayscale method does not support quantization. Replace with
+# tf.image.rgb_to_grayscale after quantization support is added.
+def _rgb_to_grayscale(images, name=None):
+ """Converts one or more images from RGB to Grayscale.
+
+ Outputs a tensor of the same `DType` and rank as `images`. The size of the
+ last dimension of the output is 1, containing the Grayscale value of the
+ pixels.
+
+ Args:
+ images: The RGB tensor to convert. Last dimension must have size 3 and
+ should contain RGB values.
+ name: A name for the operation (optional).
+
+ Returns:
+ The converted grayscale image(s).
+ """
+ with tf.name_scope(name, 'rgb_to_grayscale', [images]) as name:
+ images = tf.convert_to_tensor(images, name='images')
+ # Remember original dtype to so we can convert back if needed
+ orig_dtype = images.dtype
+ flt_image = tf.image.convert_image_dtype(images, tf.float32)
+
+ # Reference for converting between RGB and grayscale.
+ # https://en.wikipedia.org/wiki/Luma_%28video%29
+ rgb_weights = [0.2989, 0.5870, 0.1140]
+ rank_1 = tf.expand_dims(tf.rank(images) - 1, 0)
+ gray_float = tf.reduce_sum(
+ flt_image * rgb_weights, rank_1, keep_dims=True)
+ gray_float.set_shape(images.get_shape()[:-1].concatenate([1]))
+ return tf.image.convert_image_dtype(gray_float, orig_dtype, name=name)
+
+
+def normalize_image(image, original_minval, original_maxval, target_minval,
+ target_maxval):
+ """Normalizes pixel values in the image.
+
+ Moves the pixel values from the current [original_minval, original_maxval]
+ range to a the [target_minval, target_maxval] range.
+
+ Args:
+ image: rank 3 float32 tensor containing 1
+ image -> [height, width, channels].
+ original_minval: current image minimum value.
+ original_maxval: current image maximum value.
+ target_minval: target image minimum value.
+ target_maxval: target image maximum value.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('NormalizeImage', values=[image]):
+ original_minval = float(original_minval)
+ original_maxval = float(original_maxval)
+ target_minval = float(target_minval)
+ target_maxval = float(target_maxval)
+ image = tf.cast(image, dtype=tf.float32)
+ image = tf.subtract(image, original_minval)
+ image = tf.multiply(image, (target_maxval - target_minval) /
+ (original_maxval - original_minval))
+ image = tf.add(image, target_minval)
+ return image
+
+
+def retain_boxes_above_threshold(boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ threshold=0.0):
+ """Retains boxes whose label weight is above a given threshold.
+
+ If the label weight for a box is missing (represented by NaN), the box is
+ retained. The boxes that don't pass the threshold will not appear in the
+ returned tensor.
+
+ Args:
+ boxes: float32 tensor of shape [num_instance, 4] representing boxes
+ location in normalized coordinates.
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ label_weights: float32 tensor of shape [num_instance] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instance] representing the
+ confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ threshold: scalar python float.
+
+ Returns:
+ retained_boxes: [num_retained_instance, 4]
+ retianed_labels: [num_retained_instance]
+ retained_label_weights: [num_retained_instance]
+
+ If multiclass_scores, masks, or keypoints are not None, the function also
+ returns:
+
+ retained_multiclass_scores: [num_retained_instance, num_classes]
+ retained_masks: [num_retained_instance, height, width]
+ retained_keypoints: [num_retained_instance, num_keypoints, 2]
+ """
+ with tf.name_scope('RetainBoxesAboveThreshold',
+ values=[boxes, labels, label_weights]):
+ indices = tf.where(
+ tf.logical_or(label_weights > threshold, tf.is_nan(label_weights)))
+ indices = tf.squeeze(indices, axis=1)
+ retained_boxes = tf.gather(boxes, indices)
+ retained_labels = tf.gather(labels, indices)
+ retained_label_weights = tf.gather(label_weights, indices)
+ result = [retained_boxes, retained_labels, retained_label_weights]
+
+ if label_confidences is not None:
+ retained_label_confidences = tf.gather(label_confidences, indices)
+ result.append(retained_label_confidences)
+
+ if multiclass_scores is not None:
+ retained_multiclass_scores = tf.gather(multiclass_scores, indices)
+ result.append(retained_multiclass_scores)
+
+ if masks is not None:
+ retained_masks = tf.gather(masks, indices)
+ result.append(retained_masks)
+
+ if keypoints is not None:
+ retained_keypoints = tf.gather(keypoints, indices)
+ result.append(retained_keypoints)
+
+ return result
+
+
+def drop_label_probabilistically(boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ dropped_label=None,
+ drop_probability=0.0,
+ seed=None):
+ """Drops boxes of a certain label with probability drop_probability.
+
+ Boxes of the label dropped_label will not appear in the returned tensor.
+
+ Args:
+ boxes: float32 tensor of shape [num_instance, 4] representing boxes
+ location in normalized coordinates.
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ label_weights: float32 tensor of shape [num_instance] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instance] representing the
+ confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ dropped_label: int32 id of label to drop.
+ drop_probability: float32 probability of dropping a label.
+ seed: random seed.
+
+ Returns:
+ retained_boxes: [num_retained_instance, 4]
+ retianed_labels: [num_retained_instance]
+ retained_label_weights: [num_retained_instance]
+
+ If multiclass_scores, masks, or keypoints are not None, the function also
+ returns:
+
+ retained_multiclass_scores: [num_retained_instance, num_classes]
+ retained_masks: [num_retained_instance, height, width]
+ retained_keypoints: [num_retained_instance, num_keypoints, 2]
+ """
+ with tf.name_scope('DropLabelProbabilistically',
+ values=[boxes, labels]):
+ indices = tf.where(
+ tf.logical_or(
+ tf.random_uniform(tf.shape(labels), seed=seed) > drop_probability,
+ tf.not_equal(labels, dropped_label)))
+ indices = tf.squeeze(indices, axis=1)
+
+ retained_boxes = tf.gather(boxes, indices)
+ retained_labels = tf.gather(labels, indices)
+ retained_label_weights = tf.gather(label_weights, indices)
+ result = [retained_boxes, retained_labels, retained_label_weights]
+
+ if label_confidences is not None:
+ retained_label_confidences = tf.gather(label_confidences, indices)
+ result.append(retained_label_confidences)
+
+ if multiclass_scores is not None:
+ retained_multiclass_scores = tf.gather(multiclass_scores, indices)
+ result.append(retained_multiclass_scores)
+
+ if masks is not None:
+ retained_masks = tf.gather(masks, indices)
+ result.append(retained_masks)
+
+ if keypoints is not None:
+ retained_keypoints = tf.gather(keypoints, indices)
+ result.append(retained_keypoints)
+
+ return result
+
+
+def remap_labels(labels,
+ original_labels=None,
+ new_label=None):
+ """Remaps labels that have an id in original_labels to new_label.
+
+ Args:
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ original_labels: int list of original labels that should be mapped from.
+ new_label: int label to map to
+ Returns:
+ Remapped labels
+ """
+ new_labels = labels
+ for original_label in original_labels:
+ change = tf.where(
+ tf.equal(new_labels, original_label),
+ tf.add(tf.zeros_like(new_labels), new_label - original_label),
+ tf.zeros_like(new_labels))
+ new_labels = tf.add(
+ new_labels,
+ change)
+ new_labels = tf.reshape(new_labels, tf.shape(labels))
+ return new_labels
+
+
+def _flip_boxes_left_right(boxes):
+ """Left-right flip the boxes.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Flipped boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ flipped_xmin = tf.subtract(1.0, xmax)
+ flipped_xmax = tf.subtract(1.0, xmin)
+ flipped_boxes = tf.concat([ymin, flipped_xmin, ymax, flipped_xmax], 1)
+ return flipped_boxes
+
+
+def _flip_boxes_up_down(boxes):
+ """Up-down flip the boxes.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Flipped boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ flipped_ymin = tf.subtract(1.0, ymax)
+ flipped_ymax = tf.subtract(1.0, ymin)
+ flipped_boxes = tf.concat([flipped_ymin, xmin, flipped_ymax, xmax], 1)
+ return flipped_boxes
+
+
+def _rot90_boxes(boxes):
+ """Rotate boxes counter-clockwise by 90 degrees.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Rotated boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ rotated_ymin = tf.subtract(1.0, xmax)
+ rotated_ymax = tf.subtract(1.0, xmin)
+ rotated_xmin = ymin
+ rotated_xmax = ymax
+ rotated_boxes = tf.concat(
+ [rotated_ymin, rotated_xmin, rotated_ymax, rotated_xmax], 1)
+ return rotated_boxes
+
+
+def _flip_masks_left_right(masks):
+ """Left-right flip masks.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ flipped masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ return masks[:, :, ::-1]
+
+
+def _flip_masks_up_down(masks):
+ """Up-down flip masks.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ flipped masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ return masks[:, ::-1, :]
+
+
+def _rot90_masks(masks):
+ """Rotate masks counter-clockwise by 90 degrees.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ rotated masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ masks = tf.transpose(masks, [0, 2, 1])
+ return masks[:, ::-1, :]
+
+
+def random_horizontal_flip(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ keypoint_flip_permutation=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly flips the image and detections horizontally.
+
+ The probability of flipping the image is 50%.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ keypoint_flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, keypoints, and keypoint_flip_permutation are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: if keypoints are provided but keypoint_flip_permutation is not.
+ """
+
+ def _flip_image(image):
+ # flip image
+ image_flipped = tf.image.flip_left_right(image)
+ return image_flipped
+
+ if keypoints is not None and keypoint_flip_permutation is None:
+ raise ValueError(
+ 'keypoints are provided but keypoints_flip_permutation is not provided')
+
+ with tf.name_scope('RandomHorizontalFlip', values=[image, boxes]):
+ result = []
+ # random variable defining whether to do flip or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_flip_random = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.HORIZONTAL_FLIP,
+ preprocess_vars_cache)
+ do_a_flip_random = tf.greater(do_a_flip_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_flip_random, lambda: _flip_image(image), lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_flip_random, lambda: _flip_boxes_left_right(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_flip_random, lambda: _flip_masks_left_right(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None and keypoint_flip_permutation is not None:
+ permutation = keypoint_flip_permutation
+ keypoints = tf.cond(
+ do_a_flip_random,
+ lambda: keypoint_ops.flip_horizontal(keypoints, 0.5, permutation),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_vertical_flip(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ keypoint_flip_permutation=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly flips the image and detections vertically.
+
+ The probability of flipping the image is 50%.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ keypoint_flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, keypoints, and keypoint_flip_permutation are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: if keypoints are provided but keypoint_flip_permutation is not.
+ """
+
+ def _flip_image(image):
+ # flip image
+ image_flipped = tf.image.flip_up_down(image)
+ return image_flipped
+
+ if keypoints is not None and keypoint_flip_permutation is None:
+ raise ValueError(
+ 'keypoints are provided but keypoints_flip_permutation is not provided')
+
+ with tf.name_scope('RandomVerticalFlip', values=[image, boxes]):
+ result = []
+ # random variable defining whether to do flip or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_flip_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.VERTICAL_FLIP,
+ preprocess_vars_cache)
+ do_a_flip_random = tf.greater(do_a_flip_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_flip_random, lambda: _flip_image(image), lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_flip_random, lambda: _flip_boxes_up_down(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_flip_random, lambda: _flip_masks_up_down(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None and keypoint_flip_permutation is not None:
+ permutation = keypoint_flip_permutation
+ keypoints = tf.cond(
+ do_a_flip_random,
+ lambda: keypoint_ops.flip_vertical(keypoints, 0.5, permutation),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_rotation90(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly rotates the image and detections 90 degrees counter-clockwise.
+
+ The probability of rotating the image is 50%. This can be combined with
+ random_horizontal_flip and random_vertical_flip to produce an output with a
+ uniform distribution of the eight possible 90 degree rotation / reflection
+ combinations.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, and keypoints, are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def _rot90_image(image):
+ # flip image
+ image_rotated = tf.image.rot90(image)
+ return image_rotated
+
+ with tf.name_scope('RandomRotation90', values=[image, boxes]):
+ result = []
+
+ # random variable defining whether to rotate by 90 degrees or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_rot90_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.ROTATION90,
+ preprocess_vars_cache)
+ do_a_rot90_random = tf.greater(do_a_rot90_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_rot90_random, lambda: _rot90_image(image),
+ lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_rot90_random, lambda: _rot90_boxes(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_rot90_random, lambda: _rot90_masks(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None:
+ keypoints = tf.cond(
+ do_a_rot90_random,
+ lambda: keypoint_ops.rot90(keypoints),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_pixel_value_scale(image,
+ minval=0.9,
+ maxval=1.1,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Scales each value in the pixels of the image.
+
+ This function scales each pixel independent of the other ones.
+ For each value in image tensor, draws a random number between
+ minval and maxval and multiples the values with them.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ minval: lower ratio of scaling pixel values.
+ maxval: upper ratio of scaling pixel values.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomPixelValueScale', values=[image]):
+ generator_func = functools.partial(
+ tf.random_uniform, tf.shape(image),
+ minval=minval, maxval=maxval,
+ dtype=tf.float32, seed=seed)
+ color_coef = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.PIXEL_VALUE_SCALE,
+ preprocess_vars_cache)
+
+ image = tf.multiply(image, color_coef)
+ image = tf.clip_by_value(image, 0.0, 255.0)
+
+ return image
+
+
+def random_image_scale(image,
+ masks=None,
+ min_scale_ratio=0.5,
+ max_scale_ratio=2.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Scales the image size.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels].
+ masks: (optional) rank 3 float32 tensor containing masks with
+ size [height, width, num_masks]. The value is set to None if there are no
+ masks.
+ min_scale_ratio: minimum scaling ratio.
+ max_scale_ratio: maximum scaling ratio.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ masks: If masks is not none, resized masks which are the same rank as input
+ masks will be returned.
+ """
+ with tf.name_scope('RandomImageScale', values=[image]):
+ result = []
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ generator_func = functools.partial(
+ tf.random_uniform, [],
+ minval=min_scale_ratio, maxval=max_scale_ratio,
+ dtype=tf.float32, seed=seed)
+ size_coef = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.IMAGE_SCALE,
+ preprocess_vars_cache)
+
+ image_newysize = tf.cast(
+ tf.multiply(tf.cast(image_height, dtype=tf.float32), size_coef),
+ dtype=tf.int32)
+ image_newxsize = tf.cast(
+ tf.multiply(tf.cast(image_width, dtype=tf.float32), size_coef),
+ dtype=tf.int32)
+ image = tf.image.resize_images(
+ image, [image_newysize, image_newxsize], align_corners=True)
+ result.append(image)
+ if masks is not None:
+ masks = tf.image.resize_images(
+ masks, [image_newysize, image_newxsize],
+ method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
+ align_corners=True)
+ result.append(masks)
+ return tuple(result)
+
+
+def _augment_only_rgb_channels(image, augment_function):
+ """Augments only the RGB slice of an image with additional channels."""
+ rgb_slice = image[:, :, :3]
+ augmented_rgb_slice = augment_function(rgb_slice)
+ image = tf.concat([augmented_rgb_slice, image[:, :, 3:]], -1)
+ return image
+
+
+def random_rgb_to_gray(image,
+ probability=0.1,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Changes the image from RGB to Grayscale with the given probability.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ probability: the probability of returning a grayscale image.
+ The probability should be a number between [0, 1].
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ def _image_to_gray(image):
+ image_gray1 = _rgb_to_grayscale(image)
+ image_gray3 = tf.image.grayscale_to_rgb(image_gray1)
+ return image_gray3
+
+ with tf.name_scope('RandomRGBtoGray', values=[image]):
+ # random variable defining whether to change to grayscale or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_gray_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.RGB_TO_GRAY,
+ preprocess_vars_cache)
+
+ image = tf.cond(
+ tf.greater(do_gray_random, probability), lambda: image,
+ lambda: _augment_only_rgb_channels(image, _image_to_gray))
+
+ return image
+
+
+def random_adjust_brightness(image,
+ max_delta=0.2,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts brightness.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ max_delta: how much to change the brightness. A value between [0, 1).
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ boxes: boxes which is the same shape as input boxes.
+ """
+ with tf.name_scope('RandomAdjustBrightness', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ -max_delta, max_delta, seed=seed)
+ delta = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_BRIGHTNESS,
+ preprocess_vars_cache)
+
+ def _adjust_brightness(image):
+ image = tf.image.adjust_brightness(image / 255, delta) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+
+ image = _augment_only_rgb_channels(image, _adjust_brightness)
+ return image
+
+
+def random_adjust_contrast(image,
+ min_delta=0.8,
+ max_delta=1.25,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts contrast.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ min_delta: see max_delta.
+ max_delta: how much to change the contrast. Contrast will change with a
+ value between min_delta and max_delta. This value will be
+ multiplied to the current contrast of the image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustContrast', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_delta, max_delta, seed=seed)
+ contrast_factor = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_CONTRAST,
+ preprocess_vars_cache)
+
+ def _adjust_contrast(image):
+ image = tf.image.adjust_contrast(image / 255, contrast_factor) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_contrast)
+ return image
+
+
+def random_adjust_hue(image,
+ max_delta=0.02,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts hue.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ max_delta: change hue randomly with a value between 0 and max_delta.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustHue', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ -max_delta, max_delta, seed=seed)
+ delta = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.ADJUST_HUE,
+ preprocess_vars_cache)
+ def _adjust_hue(image):
+ image = tf.image.adjust_hue(image / 255, delta) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_hue)
+ return image
+
+
+def random_adjust_saturation(image,
+ min_delta=0.8,
+ max_delta=1.25,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts saturation.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ min_delta: see max_delta.
+ max_delta: how much to change the saturation. Saturation will change with a
+ value between min_delta and max_delta. This value will be
+ multiplied to the current saturation of the image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustSaturation', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_delta, max_delta, seed=seed)
+ saturation_factor = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_SATURATION,
+ preprocess_vars_cache)
+ def _adjust_saturation(image):
+ image = tf.image.adjust_saturation(image / 255, saturation_factor) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_saturation)
+ return image
+
+
+def random_distort_color(image, color_ordering=0, preprocess_vars_cache=None):
+ """Randomly distorts color.
+
+ Randomly distorts color using a combination of brightness, hue, contrast and
+ saturation changes. Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ color_ordering: Python int, a type of distortion (valid values: 0, 1).
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ Raises:
+ ValueError: if color_ordering is not in {0, 1}.
+ """
+ with tf.name_scope('RandomDistortColor', values=[image]):
+ if color_ordering == 0:
+ image = random_adjust_brightness(
+ image, max_delta=32. / 255.,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_saturation(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_hue(
+ image, max_delta=0.2,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_contrast(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ elif color_ordering == 1:
+ image = random_adjust_brightness(
+ image, max_delta=32. / 255.,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_contrast(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_saturation(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_hue(
+ image, max_delta=0.2,
+ preprocess_vars_cache=preprocess_vars_cache)
+ else:
+ raise ValueError('color_ordering must be in {0, 1}')
+ return image
+
+
+def random_jitter_boxes(boxes, ratio=0.05, seed=None):
+ """Randomly jitter boxes in image.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ ratio: The ratio of the box width and height that the corners can jitter.
+ For example if the width is 100 pixels and ratio is 0.05,
+ the corners can jitter up to 5 pixels in the x direction.
+ seed: random seed.
+
+ Returns:
+ boxes: boxes which is the same shape as input boxes.
+ """
+ def random_jitter_box(box, ratio, seed):
+ """Randomly jitter box.
+
+ Args:
+ box: bounding box [1, 1, 4].
+ ratio: max ratio between jittered box and original box,
+ a number between [0, 0.5].
+ seed: random seed.
+
+ Returns:
+ jittered_box: jittered box.
+ """
+ rand_numbers = tf.random_uniform(
+ [1, 1, 4], minval=-ratio, maxval=ratio, dtype=tf.float32, seed=seed)
+ box_width = tf.subtract(box[0, 0, 3], box[0, 0, 1])
+ box_height = tf.subtract(box[0, 0, 2], box[0, 0, 0])
+ hw_coefs = tf.stack([box_height, box_width, box_height, box_width])
+ hw_rand_coefs = tf.multiply(hw_coefs, rand_numbers)
+ jittered_box = tf.add(box, hw_rand_coefs)
+ jittered_box = tf.clip_by_value(jittered_box, 0.0, 1.0)
+ return jittered_box
+
+ with tf.name_scope('RandomJitterBoxes', values=[boxes]):
+ # boxes are [N, 4]. Lets first make them [N, 1, 1, 4]
+ boxes_shape = tf.shape(boxes)
+ boxes = tf.expand_dims(boxes, 1)
+ boxes = tf.expand_dims(boxes, 2)
+
+ distorted_boxes = tf.map_fn(
+ lambda x: random_jitter_box(x, ratio, seed), boxes, dtype=tf.float32)
+
+ distorted_boxes = tf.reshape(distorted_boxes, boxes_shape)
+
+ return distorted_boxes
+
+
+def _strict_random_crop_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ preprocess_vars_cache=None):
+ """Performs random crop.
+
+ Note: Keypoint coordinates that are outside the crop will be set to NaN, which
+ is consistent with the original keypoint encoding for non-existing keypoints.
+ This function always crops the image and is supposed to be used by
+ `random_crop_image` function which sometimes returns the image unchanged.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope('RandomCropImage', values=[image, boxes]):
+ image_shape = tf.shape(image)
+
+ # boxes are [N, 4]. Lets first make them [N, 1, 4].
+ boxes_expanded = tf.expand_dims(
+ tf.clip_by_value(
+ boxes, clip_value_min=0.0, clip_value_max=1.0), 1)
+
+ generator_func = functools.partial(
+ tf.image.sample_distorted_bounding_box,
+ image_shape,
+ bounding_boxes=boxes_expanded,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ max_attempts=100,
+ use_image_if_no_bounding_boxes=True)
+
+ # for ssd cropping, each value of min_object_covered has its own
+ # cached random variable
+ sample_distorted_bounding_box = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.STRICT_CROP_IMAGE,
+ preprocess_vars_cache, key=min_object_covered)
+
+ im_box_begin, im_box_size, im_box = sample_distorted_bounding_box
+
+ new_image = tf.slice(image, im_box_begin, im_box_size)
+ new_image.set_shape([None, None, image.get_shape()[2]])
+
+ # [1, 4]
+ im_box_rank2 = tf.squeeze(im_box, axis=[0])
+ # [4]
+ im_box_rank1 = tf.squeeze(im_box)
+
+ boxlist = box_list.BoxList(boxes)
+ boxlist.add_field('labels', labels)
+
+ if label_weights is not None:
+ boxlist.add_field('label_weights', label_weights)
+
+ if label_confidences is not None:
+ boxlist.add_field('label_confidences', label_confidences)
+
+ if multiclass_scores is not None:
+ boxlist.add_field('multiclass_scores', multiclass_scores)
+
+ im_boxlist = box_list.BoxList(im_box_rank2)
+
+ # remove boxes that are outside cropped image
+ boxlist, inside_window_ids = box_list_ops.prune_completely_outside_window(
+ boxlist, im_box_rank1)
+
+ # remove boxes that are outside image
+ overlapping_boxlist, keep_ids = box_list_ops.prune_non_overlapping_boxes(
+ boxlist, im_boxlist, overlap_thresh)
+
+ # change the coordinate of the remaining boxes
+ new_labels = overlapping_boxlist.get_field('labels')
+ new_boxlist = box_list_ops.change_coordinate_frame(overlapping_boxlist,
+ im_box_rank1)
+ new_boxes = new_boxlist.get()
+ if clip_boxes:
+ new_boxes = tf.clip_by_value(
+ new_boxes, clip_value_min=0.0, clip_value_max=1.0)
+
+ result = [new_image, new_boxes, new_labels]
+
+ if label_weights is not None:
+ new_label_weights = overlapping_boxlist.get_field('label_weights')
+ result.append(new_label_weights)
+
+ if label_confidences is not None:
+ new_label_confidences = overlapping_boxlist.get_field('label_confidences')
+ result.append(new_label_confidences)
+
+ if multiclass_scores is not None:
+ new_multiclass_scores = overlapping_boxlist.get_field('multiclass_scores')
+ result.append(new_multiclass_scores)
+
+ if masks is not None:
+ masks_of_boxes_inside_window = tf.gather(masks, inside_window_ids)
+ masks_of_boxes_completely_inside_window = tf.gather(
+ masks_of_boxes_inside_window, keep_ids)
+ masks_box_begin = [0, im_box_begin[0], im_box_begin[1]]
+ masks_box_size = [-1, im_box_size[0], im_box_size[1]]
+ new_masks = tf.slice(
+ masks_of_boxes_completely_inside_window,
+ masks_box_begin, masks_box_size)
+ result.append(new_masks)
+
+ if keypoints is not None:
+ keypoints_of_boxes_inside_window = tf.gather(keypoints, inside_window_ids)
+ keypoints_of_boxes_completely_inside_window = tf.gather(
+ keypoints_of_boxes_inside_window, keep_ids)
+ new_keypoints = keypoint_ops.change_coordinate_frame(
+ keypoints_of_boxes_completely_inside_window, im_box_rank1)
+ if clip_boxes:
+ new_keypoints = keypoint_ops.prune_outside_window(new_keypoints,
+ [0.0, 0.0, 1.0, 1.0])
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_crop_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops the image.
+
+ Given the input image and its bounding boxes, this op randomly
+ crops a subimage. Given a user-provided set of input constraints,
+ the crop window is resampled until it satisfies these constraints.
+ If within 100 trials it is unable to find a valid crop, the original
+ image is returned. See the Args section for a description of the input
+ constraints. Both input boxes and returned Boxes are in normalized
+ form (e.g., lie in the unit square [0, 1]).
+ This function will return the original image with probability random_coef.
+
+ Note: Keypoint coordinates that are outside the crop will be set to NaN, which
+ is consistent with the original keypoint encoding for non-existing keypoints.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances].
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def strict_random_crop_image_fn():
+ return _strict_random_crop_image(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ # avoids tf.cond to make faster RCNN training on borg. See b/140057645.
+ if random_coef < sys.float_info.min:
+ result = strict_random_crop_image_fn()
+ else:
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_crop_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.CROP_IMAGE,
+ preprocess_vars_cache)
+ do_a_crop_random = tf.greater(do_a_crop_random, random_coef)
+
+ outputs = [image, boxes, labels]
+
+ if label_weights is not None:
+ outputs.append(label_weights)
+ if label_confidences is not None:
+ outputs.append(label_confidences)
+ if multiclass_scores is not None:
+ outputs.append(multiclass_scores)
+ if masks is not None:
+ outputs.append(masks)
+ if keypoints is not None:
+ outputs.append(keypoints)
+
+ result = tf.cond(do_a_crop_random, strict_random_crop_image_fn,
+ lambda: tuple(outputs))
+ return result
+
+
+def random_pad_image(image,
+ boxes,
+ keypoints=None,
+ min_image_size=None,
+ max_image_size=None,
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly pads the image.
+
+ This function randomly pads the image with zeros. The final size of the
+ padded image will be between min_image_size and max_image_size.
+ if min_image_size is smaller than the input image size, min_image_size will
+ be set to the input image size. The same for max_image_size. The input image
+ will be located at a uniformly random location inside the padded image.
+ The relative location of the boxes to the original image will remain the same.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [N, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ min_image_size: a tensor of size [min_height, min_width], type tf.int32.
+ If passed as None, will be set to image size
+ [height, width].
+ max_image_size: a tensor of size [max_height, max_width], type tf.int32.
+ If passed as None, will be set to twice the
+ image [height * 2, width * 2].
+ pad_color: padding color. A rank 1 tensor of [channels] with dtype=
+ tf.float32. if set as None, it will be set to average color of
+ the input image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+
+ if keypoints is not None, the function also returns:
+ keypoints: rank 3 float32 tensor with shape [N, num_keypoints, 2]
+ """
+ if pad_color is None:
+ pad_color = tf.reduce_mean(image, axis=[0, 1])
+
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+
+ if max_image_size is None:
+ max_image_size = tf.stack([image_height * 2, image_width * 2])
+ max_image_size = tf.maximum(max_image_size,
+ tf.stack([image_height, image_width]))
+
+ if min_image_size is None:
+ min_image_size = tf.stack([image_height, image_width])
+ min_image_size = tf.maximum(min_image_size,
+ tf.stack([image_height, image_width]))
+
+ target_height = tf.cond(
+ max_image_size[0] > min_image_size[0],
+ lambda: _random_integer(min_image_size[0], max_image_size[0], seed),
+ lambda: max_image_size[0])
+
+ target_width = tf.cond(
+ max_image_size[1] > min_image_size[1],
+ lambda: _random_integer(min_image_size[1], max_image_size[1], seed),
+ lambda: max_image_size[1])
+
+ offset_height = tf.cond(
+ target_height > image_height,
+ lambda: _random_integer(0, target_height - image_height, seed),
+ lambda: tf.constant(0, dtype=tf.int32))
+
+ offset_width = tf.cond(
+ target_width > image_width,
+ lambda: _random_integer(0, target_width - image_width, seed),
+ lambda: tf.constant(0, dtype=tf.int32))
+
+ gen_func = lambda: (target_height, target_width, offset_height, offset_width)
+ params = _get_or_create_preprocess_rand_vars(
+ gen_func, preprocessor_cache.PreprocessorCache.PAD_IMAGE,
+ preprocess_vars_cache)
+ target_height, target_width, offset_height, offset_width = params
+
+ new_image = tf.image.pad_to_bounding_box(
+ image,
+ offset_height=offset_height,
+ offset_width=offset_width,
+ target_height=target_height,
+ target_width=target_width)
+
+ # Setting color of the padded pixels
+ image_ones = tf.ones_like(image)
+ image_ones_padded = tf.image.pad_to_bounding_box(
+ image_ones,
+ offset_height=offset_height,
+ offset_width=offset_width,
+ target_height=target_height,
+ target_width=target_width)
+ image_color_padded = (1.0 - image_ones_padded) * pad_color
+ new_image += image_color_padded
+
+ # setting boxes
+ new_window = tf.cast(
+ tf.stack([
+ -offset_height, -offset_width, target_height - offset_height,
+ target_width - offset_width
+ ]),
+ dtype=tf.float32)
+ new_window /= tf.cast(
+ tf.stack([image_height, image_width, image_height, image_width]),
+ dtype=tf.float32)
+ boxlist = box_list.BoxList(boxes)
+ new_boxlist = box_list_ops.change_coordinate_frame(boxlist, new_window)
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes]
+
+ if keypoints is not None:
+ new_keypoints = keypoint_ops.change_coordinate_frame(keypoints, new_window)
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_absolute_pad_image(image,
+ boxes,
+ max_height_padding,
+ max_width_padding,
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly pads the image by small absolute amounts.
+
+ As random_pad_image above, but the padding is of size [0, max_height_padding]
+ or [0, max_width_padding] instead of padding to a fixed size of
+ max_height_padding for all images.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ max_height_padding: a scalar tf.int32 tensor denoting the maximum amount of
+ height padding. The padding will be chosen uniformly at
+ random from [0, max_height_padding).
+ max_width_padding: a scalar tf.int32 tensor denoting the maximum amount of
+ width padding. The padding will be chosen uniformly at
+ random from [0, max_width_padding).
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the input
+ image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ """
+ min_image_size = tf.shape(image)[:2]
+ max_image_size = min_image_size + tf.cast(
+ [max_height_padding, max_width_padding], dtype=tf.int32)
+ return random_pad_image(image, boxes, min_image_size=min_image_size,
+ max_image_size=max_image_size, pad_color=pad_color,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+
+def random_crop_pad_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ random_coef=0.0,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops and pads the image.
+
+ Given an input image and its bounding boxes, this op first randomly crops
+ the image and then randomly pads the image with background values. Parameters
+ min_padded_size_ratio and max_padded_size_ratio, determine the range of the
+ final output image size. Specifically, the final image size will have a size
+ in the range of min_padded_size_ratio * tf.shape(image) and
+ max_padded_size_ratio * tf.shape(image). Note that these ratios are with
+ respect to the size of the original image, so we can't capture the same
+ effect easily by independently applying RandomCropImage
+ followed by RandomPadImage.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 containing the label weights.
+ label_confidences: rank 1 float32 containing the label confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the randomly
+ cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ padded_image: padded image.
+ padded_boxes: boxes which is the same rank as input boxes. Boxes are in
+ normalized form.
+ cropped_labels: cropped labels.
+ if label_weights is not None also returns:
+ cropped_label_weights: cropped label weights.
+ if multiclass_scores is not None also returns:
+ cropped_multiclass_scores: cropped_multiclass_scores.
+
+ """
+ image_size = tf.shape(image)
+ image_height = image_size[0]
+ image_width = image_size[1]
+ result = random_crop_image(
+ image=image,
+ boxes=boxes,
+ labels=labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ cropped_image, cropped_boxes, cropped_labels = result[:3]
+
+ min_image_size = tf.cast(
+ tf.cast(tf.stack([image_height, image_width]), dtype=tf.float32) *
+ min_padded_size_ratio,
+ dtype=tf.int32)
+ max_image_size = tf.cast(
+ tf.cast(tf.stack([image_height, image_width]), dtype=tf.float32) *
+ max_padded_size_ratio,
+ dtype=tf.int32)
+
+ padded_image, padded_boxes = random_pad_image(
+ cropped_image,
+ cropped_boxes,
+ min_image_size=min_image_size,
+ max_image_size=max_image_size,
+ pad_color=pad_color,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ cropped_padded_output = (padded_image, padded_boxes, cropped_labels)
+
+ index = 3
+ if label_weights is not None:
+ cropped_label_weights = result[index]
+ cropped_padded_output += (cropped_label_weights,)
+ index += 1
+
+ if label_confidences is not None:
+ cropped_label_confidences = result[index]
+ cropped_padded_output += (cropped_label_confidences,)
+ index += 1
+
+ if multiclass_scores is not None:
+ cropped_multiclass_scores = result[index]
+ cropped_padded_output += (cropped_multiclass_scores,)
+
+ return cropped_padded_output
+
+
+def random_crop_to_aspect_ratio(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ aspect_ratio=1.0,
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops an image to the specified aspect ratio.
+
+ Randomly crops the a portion of the image such that the crop is of the
+ specified aspect ratio, and the crop is as large as possible. If the specified
+ aspect ratio is larger than the aspect ratio of the image, this op will
+ randomly remove rows from the top and bottom of the image. If the specified
+ aspect ratio is less than the aspect ratio of the image, this op will randomly
+ remove cols from the left and right of the image. If the specified aspect
+ ratio is the same as the aspect ratio of the image, this op will return the
+ image.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ aspect_ratio: the aspect ratio of cropped image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, masks, keypoints, or multiclass_scores is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+
+ Raises:
+ ValueError: If image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('RandomCropToAspectRatio', values=[image]):
+ image_shape = tf.shape(image)
+ orig_height = image_shape[0]
+ orig_width = image_shape[1]
+ orig_aspect_ratio = tf.cast(
+ orig_width, dtype=tf.float32) / tf.cast(
+ orig_height, dtype=tf.float32)
+ new_aspect_ratio = tf.constant(aspect_ratio, dtype=tf.float32)
+
+ def target_height_fn():
+ return tf.cast(
+ tf.round(tf.cast(orig_width, dtype=tf.float32) / new_aspect_ratio),
+ dtype=tf.int32)
+
+ target_height = tf.cond(orig_aspect_ratio >= new_aspect_ratio,
+ lambda: orig_height, target_height_fn)
+
+ def target_width_fn():
+ return tf.cast(
+ tf.round(tf.cast(orig_height, dtype=tf.float32) * new_aspect_ratio),
+ dtype=tf.int32)
+
+ target_width = tf.cond(orig_aspect_ratio <= new_aspect_ratio,
+ lambda: orig_width, target_width_fn)
+
+ # either offset_height = 0 and offset_width is randomly chosen from
+ # [0, offset_width - target_width), or else offset_width = 0 and
+ # offset_height is randomly chosen from [0, offset_height - target_height)
+ offset_height = _random_integer(0, orig_height - target_height + 1, seed)
+ offset_width = _random_integer(0, orig_width - target_width + 1, seed)
+
+ generator_func = lambda: (offset_height, offset_width)
+ offset_height, offset_width = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.CROP_TO_ASPECT_RATIO,
+ preprocess_vars_cache)
+
+ new_image = tf.image.crop_to_bounding_box(
+ image, offset_height, offset_width, target_height, target_width)
+
+ im_box = tf.stack([
+ tf.cast(offset_height, dtype=tf.float32) /
+ tf.cast(orig_height, dtype=tf.float32),
+ tf.cast(offset_width, dtype=tf.float32) /
+ tf.cast(orig_width, dtype=tf.float32),
+ tf.cast(offset_height + target_height, dtype=tf.float32) /
+ tf.cast(orig_height, dtype=tf.float32),
+ tf.cast(offset_width + target_width, dtype=tf.float32) /
+ tf.cast(orig_width, dtype=tf.float32)
+ ])
+
+ boxlist = box_list.BoxList(boxes)
+ boxlist.add_field('labels', labels)
+
+ boxlist.add_field('label_weights', label_weights)
+
+ if label_confidences is not None:
+ boxlist.add_field('label_confidences', label_confidences)
+
+ if multiclass_scores is not None:
+ boxlist.add_field('multiclass_scores', multiclass_scores)
+
+ im_boxlist = box_list.BoxList(tf.expand_dims(im_box, 0))
+
+ # remove boxes whose overlap with the image is less than overlap_thresh
+ overlapping_boxlist, keep_ids = box_list_ops.prune_non_overlapping_boxes(
+ boxlist, im_boxlist, overlap_thresh)
+
+ # change the coordinate of the remaining boxes
+ new_labels = overlapping_boxlist.get_field('labels')
+ new_boxlist = box_list_ops.change_coordinate_frame(overlapping_boxlist,
+ im_box)
+ if clip_boxes:
+ new_boxlist = box_list_ops.clip_to_window(
+ new_boxlist, tf.constant([0.0, 0.0, 1.0, 1.0], tf.float32))
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes, new_labels]
+
+ new_label_weights = overlapping_boxlist.get_field('label_weights')
+ result.append(new_label_weights)
+
+ if label_confidences is not None:
+ new_label_confidences = (
+ overlapping_boxlist.get_field('label_confidences'))
+ result.append(new_label_confidences)
+
+ if multiclass_scores is not None:
+ new_multiclass_scores = overlapping_boxlist.get_field('multiclass_scores')
+ result.append(new_multiclass_scores)
+
+ if masks is not None:
+ masks_inside_window = tf.gather(masks, keep_ids)
+ masks_box_begin = tf.stack([0, offset_height, offset_width])
+ masks_box_size = tf.stack([-1, target_height, target_width])
+ new_masks = tf.slice(masks_inside_window, masks_box_begin, masks_box_size)
+ result.append(new_masks)
+
+ if keypoints is not None:
+ keypoints_inside_window = tf.gather(keypoints, keep_ids)
+ new_keypoints = keypoint_ops.change_coordinate_frame(
+ keypoints_inside_window, im_box)
+ if clip_boxes:
+ new_keypoints = keypoint_ops.prune_outside_window(new_keypoints,
+ [0.0, 0.0, 1.0, 1.0])
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_pad_to_aspect_ratio(image,
+ boxes,
+ masks=None,
+ keypoints=None,
+ aspect_ratio=1.0,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly zero pads an image to the specified aspect ratio.
+
+ Pads the image so that the resulting image will have the specified aspect
+ ratio without scaling less than the min_padded_size_ratio or more than the
+ max_padded_size_ratio. If the min_padded_size_ratio or max_padded_size_ratio
+ is lower than what is possible to maintain the aspect ratio, then this method
+ will use the least padding to achieve the specified aspect ratio.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ aspect_ratio: aspect ratio of the final image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If masks, or keypoints is not None, the function also returns:
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: If image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('RandomPadToAspectRatio', values=[image]):
+ image_shape = tf.shape(image)
+ image_height = tf.cast(image_shape[0], dtype=tf.float32)
+ image_width = tf.cast(image_shape[1], dtype=tf.float32)
+ image_aspect_ratio = image_width / image_height
+ new_aspect_ratio = tf.constant(aspect_ratio, dtype=tf.float32)
+ target_height = tf.cond(
+ image_aspect_ratio <= new_aspect_ratio,
+ lambda: image_height,
+ lambda: image_width / new_aspect_ratio)
+ target_width = tf.cond(
+ image_aspect_ratio >= new_aspect_ratio,
+ lambda: image_width,
+ lambda: image_height * new_aspect_ratio)
+
+ min_height = tf.maximum(
+ min_padded_size_ratio[0] * image_height, target_height)
+ min_width = tf.maximum(
+ min_padded_size_ratio[1] * image_width, target_width)
+ max_height = tf.maximum(
+ max_padded_size_ratio[0] * image_height, target_height)
+ max_width = tf.maximum(
+ max_padded_size_ratio[1] * image_width, target_width)
+
+ max_scale = tf.minimum(max_height / target_height, max_width / target_width)
+ min_scale = tf.minimum(
+ max_scale,
+ tf.maximum(min_height / target_height, min_width / target_width))
+
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_scale, max_scale, seed=seed)
+ scale = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.PAD_TO_ASPECT_RATIO,
+ preprocess_vars_cache)
+
+ target_height = tf.round(scale * target_height)
+ target_width = tf.round(scale * target_width)
+
+ new_image = tf.image.pad_to_bounding_box(
+ image, 0, 0, tf.cast(target_height, dtype=tf.int32),
+ tf.cast(target_width, dtype=tf.int32))
+
+ im_box = tf.stack([
+ 0.0,
+ 0.0,
+ target_height / image_height,
+ target_width / image_width
+ ])
+ boxlist = box_list.BoxList(boxes)
+ new_boxlist = box_list_ops.change_coordinate_frame(boxlist, im_box)
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes]
+
+ if masks is not None:
+ new_masks = tf.expand_dims(masks, -1)
+ new_masks = tf.image.pad_to_bounding_box(
+ new_masks, 0, 0, tf.cast(target_height, dtype=tf.int32),
+ tf.cast(target_width, dtype=tf.int32))
+ new_masks = tf.squeeze(new_masks, [-1])
+ result.append(new_masks)
+
+ if keypoints is not None:
+ new_keypoints = keypoint_ops.change_coordinate_frame(keypoints, im_box)
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_black_patches(image,
+ max_black_patches=10,
+ probability=0.5,
+ size_to_image_ratio=0.1,
+ random_seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adds some black patches to the image.
+
+ This op adds up to max_black_patches square black patches of a fixed size
+ to the image where size is specified via the size_to_image_ratio parameter.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ max_black_patches: number of times that the function tries to add a
+ black box to the image.
+ probability: at each try, what is the chance of adding a box.
+ size_to_image_ratio: Determines the ratio of the size of the black patches
+ to the size of the image.
+ box_size = size_to_image_ratio *
+ min(image_width, image_height)
+ random_seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image
+ """
+ def add_black_patch_to_image(image, idx):
+ """Function for adding one patch to the image.
+
+ Args:
+ image: image
+ idx: counter for number of patches that could have been added
+
+ Returns:
+ image with a randomly added black box
+ """
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ box_size = tf.cast(
+ tf.multiply(
+ tf.minimum(
+ tf.cast(image_height, dtype=tf.float32),
+ tf.cast(image_width, dtype=tf.float32)), size_to_image_ratio),
+ dtype=tf.int32)
+
+ generator_func = functools.partial(tf.random_uniform, [], minval=0.0,
+ maxval=(1.0 - size_to_image_ratio),
+ seed=random_seed)
+ normalized_y_min = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADD_BLACK_PATCH,
+ preprocess_vars_cache, key=str(idx) + 'y')
+ normalized_x_min = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADD_BLACK_PATCH,
+ preprocess_vars_cache, key=str(idx) + 'x')
+
+ y_min = tf.cast(
+ normalized_y_min * tf.cast(image_height, dtype=tf.float32),
+ dtype=tf.int32)
+ x_min = tf.cast(
+ normalized_x_min * tf.cast(image_width, dtype=tf.float32),
+ dtype=tf.int32)
+ black_box = tf.ones([box_size, box_size, 3], dtype=tf.float32)
+ mask = 1.0 - tf.image.pad_to_bounding_box(black_box, y_min, x_min,
+ image_height, image_width)
+ image = tf.multiply(image, mask)
+ return image
+
+ with tf.name_scope('RandomBlackPatchInImage', values=[image]):
+ for idx in range(max_black_patches):
+ generator_func = functools.partial(tf.random_uniform, [],
+ minval=0.0, maxval=1.0,
+ dtype=tf.float32, seed=random_seed)
+ random_prob = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.BLACK_PATCHES,
+ preprocess_vars_cache, key=idx)
+ image = tf.cond(
+ tf.greater(random_prob, probability), lambda: image,
+ functools.partial(add_black_patch_to_image, image=image, idx=idx))
+ return image
+
+
+def random_jpeg_quality(image,
+ min_jpeg_quality=0,
+ max_jpeg_quality=100,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly encode the image to a random JPEG quality level.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0, 255].
+ min_jpeg_quality: An int for the lower bound for selecting a random jpeg
+ quality level.
+ max_jpeg_quality: An int for the upper bound for selecting a random jpeg
+ quality level.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the encoded image,
+ and if it is 1.0, we will always get the original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this function is called
+ multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ def _adjust_jpeg_quality():
+ """Encodes the image as jpeg with a random quality and then decodes."""
+ generator_func = functools.partial(
+ tf.random_uniform, [],
+ minval=min_jpeg_quality,
+ maxval=max_jpeg_quality,
+ dtype=tf.int32,
+ seed=seed)
+ quality = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.JPEG_QUALITY,
+ preprocess_vars_cache, key='quality')
+
+ # Need to convert to uint8 before calling adjust_jpeg_quality since it
+ # assumes that float features are in the range [0, 1], where herein the
+ # range is [0, 255].
+ image_uint8 = tf.cast(image, tf.uint8)
+ adjusted_image = tf.image.adjust_jpeg_quality(image_uint8, quality)
+ return tf.cast(adjusted_image, tf.float32)
+
+ with tf.name_scope('RandomJpegQuality', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_encoding_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.JPEG_QUALITY,
+ preprocess_vars_cache)
+ do_encoding_random = tf.greater_equal(do_encoding_random, random_coef)
+ image = tf.cond(do_encoding_random, _adjust_jpeg_quality,
+ lambda: tf.cast(image, tf.float32))
+
+ return image
+
+
+def random_downscale_to_target_pixels(image,
+ masks=None,
+ min_target_pixels=300000,
+ max_target_pixels=800000,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly downscales the image to a target number of pixels.
+
+ If the image contains less than the chosen target number of pixels, it will
+ not be downscaled.
+
+ Args:
+ image: Rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0, 255].
+ masks: (optional) Rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ min_target_pixels: Integer. An inclusive lower bound for for the target
+ number of pixels.
+ max_target_pixels: Integer. An exclusive upper bound for for the target
+ number of pixels.
+ random_coef: Float. Random coefficient that defines the chance of getting
+ the original image. If random_coef is 0, we will always apply downscaling,
+ and if it is 1.0, we will always get the original image.
+ seed: (optional) Integer. Random seed.
+ preprocess_vars_cache: (optional) PreprocessorCache object that records
+ previously performed augmentations. Updated in-place. If this function is
+ called multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ Tuple with elements:
+ image: Resized image which is the same rank as input image.
+ masks: If masks is not None, resized masks which are the same rank as
+ the input masks.
+
+ Raises:
+ ValueError: If min_target_pixels or max_target_pixels are not positive.
+ """
+ if min_target_pixels <= 0:
+ raise ValueError('Minimum target pixels must be positive')
+ if max_target_pixels <= 0:
+ raise ValueError('Maximum target pixels must be positive')
+
+ def _resize_image_to_target(target_height, target_width):
+ # pylint: disable=unbalanced-tuple-unpacking
+ new_image, _ = resize_image(image, None, target_height, target_width)
+ return (new_image,)
+
+ def _resize_image_and_masks_to_target(target_height, target_width):
+ # pylint: disable=unbalanced-tuple-unpacking
+ new_image, new_masks, _ = resize_image(image, masks, target_height,
+ target_width)
+ return new_image, new_masks
+
+ with tf.name_scope('RandomDownscaleToTargetPixels', values=[image]):
+ generator_fn = functools.partial(tf.random_uniform, [], seed=seed)
+ do_downscale_random = _get_or_create_preprocess_rand_vars(
+ generator_fn,
+ preprocessor_cache.PreprocessorCache.DOWNSCALE_TO_TARGET_PIXELS,
+ preprocess_vars_cache)
+ do_downscale_random = tf.greater_equal(do_downscale_random, random_coef)
+
+ generator_fn = functools.partial(
+ tf.random_uniform, [],
+ minval=min_target_pixels,
+ maxval=max_target_pixels,
+ dtype=tf.int32,
+ seed=seed)
+ target_pixels = _get_or_create_preprocess_rand_vars(
+ generator_fn,
+ preprocessor_cache.PreprocessorCache.DOWNSCALE_TO_TARGET_PIXELS,
+ preprocess_vars_cache,
+ key='target_pixels')
+
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ image_pixels = image_height * image_width
+ scale_factor = tf.sqrt(
+ tf.cast(target_pixels, dtype=tf.float32) /
+ tf.cast(image_pixels, dtype=tf.float32))
+ target_height = tf.cast(
+ scale_factor * tf.cast(image_height, dtype=tf.float32), dtype=tf.int32)
+ target_width = tf.cast(
+ scale_factor * tf.cast(image_width, dtype=tf.float32), dtype=tf.int32)
+ image_larger_than_target = tf.greater(image_pixels, target_pixels)
+
+ should_apply_resize = tf.logical_and(do_downscale_random,
+ image_larger_than_target)
+ if masks is not None:
+ resize_fn = functools.partial(_resize_image_and_masks_to_target,
+ target_height, target_width)
+ return tf.cond(should_apply_resize, resize_fn,
+ lambda: (tf.cast(image, dtype=tf.float32), masks))
+ else:
+ resize_fn = lambda: _resize_image_to_target(target_height, target_width)
+ return tf.cond(should_apply_resize, resize_fn,
+ lambda: (tf.cast(image, dtype=tf.float32),))
+
+
+def random_patch_gaussian(image,
+ min_patch_size=1,
+ max_patch_size=250,
+ min_gaussian_stddev=0.0,
+ max_gaussian_stddev=1.0,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly applies gaussian noise to a random patch on the image.
+
+ The gaussian noise is applied to the image with values scaled to the range
+ [0.0, 1.0]. The result of applying gaussian noise to the scaled image is
+ clipped to be within the range [0.0, 1.0], equivalent to the range
+ [0.0, 255.0] after rescaling the image back.
+
+ See "Improving Robustness Without Sacrificing Accuracy with Patch Gaussian
+ Augmentation " by Lopes et al., 2019, for further details.
+ https://arxiv.org/abs/1906.02611
+
+ Args:
+ image: Rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0.0, 255.0].
+ min_patch_size: Integer. An inclusive lower bound for the patch size.
+ max_patch_size: Integer. An exclusive upper bound for the patch size.
+ min_gaussian_stddev: Float. An inclusive lower bound for the standard
+ deviation of the gaussian noise.
+ max_gaussian_stddev: Float. An exclusive upper bound for the standard
+ deviation of the gaussian noise.
+ random_coef: Float. Random coefficient that defines the chance of getting
+ the original image. If random_coef is 0.0, we will always apply
+ downscaling, and if it is 1.0, we will always get the original image.
+ seed: (optional) Integer. Random seed.
+ preprocess_vars_cache: (optional) PreprocessorCache object that records
+ previously performed augmentations. Updated in-place. If this function is
+ called multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ Rank 3 float32 tensor with same shape as the input image and with gaussian
+ noise applied within a random patch.
+
+ Raises:
+ ValueError: If min_patch_size is < 1.
+ """
+ if min_patch_size < 1:
+ raise ValueError('Minimum patch size must be >= 1.')
+
+ get_or_create_rand_vars_fn = functools.partial(
+ _get_or_create_preprocess_rand_vars,
+ function_id=preprocessor_cache.PreprocessorCache.PATCH_GAUSSIAN,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ def _apply_patch_gaussian(image):
+ """Applies a patch gaussian with random size, location, and stddev."""
+ patch_size = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=min_patch_size,
+ maxval=max_patch_size,
+ dtype=tf.int32,
+ seed=seed),
+ key='patch_size')
+ gaussian_stddev = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=min_gaussian_stddev,
+ maxval=max_gaussian_stddev,
+ dtype=tf.float32,
+ seed=seed),
+ key='gaussian_stddev')
+
+ image_shape = tf.shape(image)
+ y = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=0,
+ maxval=image_shape[0],
+ dtype=tf.int32,
+ seed=seed),
+ key='y')
+ x = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=0,
+ maxval=image_shape[1],
+ dtype=tf.int32,
+ seed=seed),
+ key='x')
+ gaussian = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random.normal,
+ image_shape,
+ stddev=gaussian_stddev,
+ dtype=tf.float32,
+ seed=seed),
+ key='gaussian')
+
+ scaled_image = image / 255.0
+ image_plus_gaussian = tf.clip_by_value(scaled_image + gaussian, 0.0, 1.0)
+ patch_mask = patch_ops.get_patch_mask(y, x, patch_size, image_shape)
+ patch_mask = tf.expand_dims(patch_mask, -1)
+ patch_mask = tf.tile(patch_mask, [1, 1, image_shape[2]])
+ patched_image = tf.where(patch_mask, image_plus_gaussian, scaled_image)
+ return patched_image * 255.0
+
+ with tf.name_scope('RandomPatchGaussian', values=[image]):
+ image = tf.cast(image, tf.float32)
+ patch_gaussian_random = get_or_create_rand_vars_fn(
+ functools.partial(tf.random_uniform, [], seed=seed))
+ do_patch_gaussian = tf.greater_equal(patch_gaussian_random, random_coef)
+ image = tf.cond(do_patch_gaussian,
+ lambda: _apply_patch_gaussian(image),
+ lambda: image)
+ return image
+
+
+# TODO(barretzoph): Put in AutoAugment Paper link when paper is live.
+def autoaugment_image(image, boxes, policy_name='v0'):
+ """Apply an autoaugment policy to the image and boxes.
+
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ policy_name: The name of the AutoAugment policy to use. The available
+ options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for
+ all of the results in the paper and was found to achieve the best results
+ on the COCO dataset. `v1`, `v2` and `v3` are additional good policies
+ found on the COCO dataset that have slight variation in what operations
+ were used during the search procedure along with how many operations are
+ applied in parallel to a single image (2 vs 3).
+
+
+ Returns:
+ image: the augmented image.
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form. boxes will have been augmented along with image.
+ """
+ return autoaugment_utils.distort_image_with_autoaugment(
+ image, boxes, policy_name)
+
+
+def image_to_float(image):
+ """Used in Faster R-CNN. Casts image pixel values to float.
+
+ Args:
+ image: input image which might be in tf.uint8 or sth else format
+
+ Returns:
+ image: image in tf.float32 format.
+ """
+ with tf.name_scope('ImageToFloat', values=[image]):
+ image = tf.cast(image, dtype=tf.float32)
+ return image
+
+
+def random_resize_method(image, target_size, preprocess_vars_cache=None):
+ """Uses a random resize method to resize the image to target size.
+
+ Args:
+ image: a rank 3 tensor.
+ target_size: a list of [target_height, target_width]
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ resized image.
+ """
+
+ resized_image = _apply_with_random_selector(
+ image,
+ lambda x, method: tf.image.resize_images(x, target_size, method),
+ num_cases=4,
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.RESIZE_METHOD)
+
+ return resized_image
+
+
+def resize_to_range(image,
+ masks=None,
+ min_dimension=None,
+ max_dimension=None,
+ method=tf.image.ResizeMethod.BILINEAR,
+ align_corners=False,
+ pad_to_max_dimension=False,
+ per_channel_pad_value=(0, 0, 0)):
+ """Resizes an image so its dimensions are within the provided value.
+
+ The output size can be described by two cases:
+ 1. If the image can be rescaled so its minimum dimension is equal to the
+ provided value without the other dimension exceeding max_dimension,
+ then do so.
+ 2. Otherwise, resize so the largest dimension is equal to max_dimension.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks.
+ min_dimension: (optional) (scalar) desired size of the smaller image
+ dimension.
+ max_dimension: (optional) (scalar) maximum allowed size
+ of the larger image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+ align_corners: bool. If true, exactly align all 4 corners of the input
+ and output. Defaults to False.
+ pad_to_max_dimension: Whether to resize the image and pad it with zeros
+ so the resulting image is of the spatial size
+ [max_dimension, max_dimension]. If masks are included they are padded
+ similarly.
+ per_channel_pad_value: A tuple of per-channel scalar value to use for
+ padding. By default pads zeros.
+
+ Returns:
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A 3D tensor of shape [new_height, new_width, channels],
+ where the image has been resized (with bilinear interpolation) so that
+ min(new_height, new_width) == min_dimension or
+ max(new_height, new_width) == max_dimension.
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width].
+ resized_image_shape: A 1D tensor of shape [3] containing shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ def _resize_landscape_image(image):
+ # resize a landscape image
+ return tf.image.resize_images(
+ image, tf.stack([min_dimension, max_dimension]), method=method,
+ align_corners=align_corners, preserve_aspect_ratio=True)
+
+ def _resize_portrait_image(image):
+ # resize a portrait image
+ return tf.image.resize_images(
+ image, tf.stack([max_dimension, min_dimension]), method=method,
+ align_corners=align_corners, preserve_aspect_ratio=True)
+
+ with tf.name_scope('ResizeToRange', values=[image, min_dimension]):
+ if image.get_shape().is_fully_defined():
+ if image.get_shape()[0] < image.get_shape()[1]:
+ new_image = _resize_landscape_image(image)
+ else:
+ new_image = _resize_portrait_image(image)
+ new_size = tf.constant(new_image.get_shape().as_list())
+ else:
+ new_image = tf.cond(
+ tf.less(tf.shape(image)[0], tf.shape(image)[1]),
+ lambda: _resize_landscape_image(image),
+ lambda: _resize_portrait_image(image))
+ new_size = tf.shape(new_image)
+
+ if pad_to_max_dimension:
+ channels = tf.unstack(new_image, axis=2)
+ if len(channels) != len(per_channel_pad_value):
+ raise ValueError('Number of channels must be equal to the length of '
+ 'per-channel pad value.')
+ new_image = tf.stack(
+ [
+ tf.pad(
+ channels[i], [[0, max_dimension - new_size[0]],
+ [0, max_dimension - new_size[1]]],
+ constant_values=per_channel_pad_value[i])
+ for i in range(len(channels))
+ ],
+ axis=2)
+ new_image.set_shape([max_dimension, max_dimension, 3])
+
+ result = [new_image]
+ if masks is not None:
+ new_masks = tf.expand_dims(masks, 3)
+ new_masks = tf.image.resize_images(
+ new_masks,
+ new_size[:-1],
+ method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
+ align_corners=align_corners)
+ if pad_to_max_dimension:
+ new_masks = tf.image.pad_to_bounding_box(
+ new_masks, 0, 0, max_dimension, max_dimension)
+ new_masks = tf.squeeze(new_masks, 3)
+ result.append(new_masks)
+
+ result.append(new_size)
+ return result
+
+
+def _get_image_info(image):
+ """Returns the height, width and number of channels in the image."""
+ image_height = tf.shape(image)[0]
+ image_width = tf.shape(image)[1]
+ num_channels = tf.shape(image)[2]
+ return (image_height, image_width, num_channels)
+
+
+# TODO(alirezafathi): Make sure the static shapes are preserved.
+def resize_to_min_dimension(image, masks=None, min_dimension=600,
+ method=tf.image.ResizeMethod.BILINEAR):
+ """Resizes image and masks given the min size maintaining the aspect ratio.
+
+ If one of the image dimensions is smaller than min_dimension, it will scale
+ the image such that its smallest dimension is equal to min_dimension.
+ Otherwise, will keep the image size as is.
+
+ Args:
+ image: a tensor of size [height, width, channels].
+ masks: (optional) a tensors of size [num_instances, height, width].
+ min_dimension: minimum image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+
+ Returns:
+ An array containing resized_image, resized_masks, and resized_image_shape.
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('ResizeGivenMinDimension', values=[image, min_dimension]):
+ (image_height, image_width, num_channels) = _get_image_info(image)
+ min_image_dimension = tf.minimum(image_height, image_width)
+ min_target_dimension = tf.maximum(min_image_dimension, min_dimension)
+ target_ratio = tf.cast(min_target_dimension, dtype=tf.float32) / tf.cast(
+ min_image_dimension, dtype=tf.float32)
+ target_height = tf.cast(
+ tf.cast(image_height, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ target_width = tf.cast(
+ tf.cast(image_width, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ image = tf.image.resize_images(
+ tf.expand_dims(image, axis=0), size=[target_height, target_width],
+ method=method,
+ align_corners=True)
+ result = [tf.squeeze(image, axis=0)]
+
+ if masks is not None:
+ masks = tf.image.resize_nearest_neighbor(
+ tf.expand_dims(masks, axis=3),
+ size=[target_height, target_width],
+ align_corners=True)
+ result.append(tf.squeeze(masks, axis=3))
+
+ result.append(tf.stack([target_height, target_width, num_channels]))
+ return result
+
+
+def resize_to_max_dimension(image, masks=None, max_dimension=600,
+ method=tf.image.ResizeMethod.BILINEAR):
+ """Resizes image and masks given the max size maintaining the aspect ratio.
+
+ If one of the image dimensions is greater than max_dimension, it will scale
+ the image such that its largest dimension is equal to max_dimension.
+ Otherwise, will keep the image size as is.
+
+ Args:
+ image: a tensor of size [height, width, channels].
+ masks: (optional) a tensors of size [num_instances, height, width].
+ max_dimension: maximum image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+
+ Returns:
+ An array containing resized_image, resized_masks, and resized_image_shape.
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('ResizeGivenMaxDimension', values=[image, max_dimension]):
+ (image_height, image_width, num_channels) = _get_image_info(image)
+ max_image_dimension = tf.maximum(image_height, image_width)
+ max_target_dimension = tf.minimum(max_image_dimension, max_dimension)
+ target_ratio = tf.cast(max_target_dimension, dtype=tf.float32) / tf.cast(
+ max_image_dimension, dtype=tf.float32)
+ target_height = tf.cast(
+ tf.cast(image_height, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ target_width = tf.cast(
+ tf.cast(image_width, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ image = tf.image.resize_images(
+ tf.expand_dims(image, axis=0), size=[target_height, target_width],
+ method=method,
+ align_corners=True)
+ result = [tf.squeeze(image, axis=0)]
+
+ if masks is not None:
+ masks = tf.image.resize_nearest_neighbor(
+ tf.expand_dims(masks, axis=3),
+ size=[target_height, target_width],
+ align_corners=True)
+ result.append(tf.squeeze(masks, axis=3))
+
+ result.append(tf.stack([target_height, target_width, num_channels]))
+ return result
+
+
+def scale_boxes_to_pixel_coordinates(image, boxes, keypoints=None):
+ """Scales boxes from normalized to pixel coordinates.
+
+ Args:
+ image: A 3D float32 tensor of shape [height, width, channels].
+ boxes: A 2D float32 tensor of shape [num_boxes, 4] containing the bounding
+ boxes in normalized coordinates. Each row is of the form
+ [ymin, xmin, ymax, xmax].
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+
+ Returns:
+ image: unchanged input image.
+ scaled_boxes: a 2D float32 tensor of shape [num_boxes, 4] containing the
+ bounding boxes in pixel coordinates.
+ scaled_keypoints: a 3D float32 tensor with shape
+ [num_instances, num_keypoints, 2] containing the keypoints in pixel
+ coordinates.
+ """
+ boxlist = box_list.BoxList(boxes)
+ image_height = tf.shape(image)[0]
+ image_width = tf.shape(image)[1]
+ scaled_boxes = box_list_ops.scale(boxlist, image_height, image_width).get()
+ result = [image, scaled_boxes]
+ if keypoints is not None:
+ scaled_keypoints = keypoint_ops.scale(keypoints, image_height, image_width)
+ result.append(scaled_keypoints)
+ return tuple(result)
+
+
+# TODO(alirezafathi): Investigate if instead the function should return None if
+# masks is None.
+# pylint: disable=g-doc-return-or-yield
+def resize_image(image,
+ masks=None,
+ new_height=600,
+ new_width=1024,
+ method=tf.image.ResizeMethod.BILINEAR,
+ align_corners=False):
+ """Resizes images to the given height and width.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks.
+ new_height: (optional) (scalar) desired height of the image.
+ new_width: (optional) (scalar) desired width of the image.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+ align_corners: bool. If true, exactly align all 4 corners of the input
+ and output. Defaults to False.
+
+ Returns:
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+ """
+ with tf.name_scope(
+ 'ResizeImage',
+ values=[image, new_height, new_width, method, align_corners]):
+ new_image = tf.image.resize_images(
+ image, tf.stack([new_height, new_width]),
+ method=method,
+ align_corners=align_corners)
+ image_shape = shape_utils.combined_static_and_dynamic_shape(image)
+ result = [new_image]
+ if masks is not None:
+ num_instances = tf.shape(masks)[0]
+ new_size = tf.stack([new_height, new_width])
+ def resize_masks_branch():
+ new_masks = tf.expand_dims(masks, 3)
+ new_masks = tf.image.resize_nearest_neighbor(
+ new_masks, new_size, align_corners=align_corners)
+ new_masks = tf.squeeze(new_masks, axis=3)
+ return new_masks
+
+ def reshape_masks_branch():
+ # The shape function will be computed for both branches of the
+ # condition, regardless of which branch is actually taken. Make sure
+ # that we don't trigger an assertion in the shape function when trying
+ # to reshape a non empty tensor into an empty one.
+ new_masks = tf.reshape(masks, [-1, new_size[0], new_size[1]])
+ return new_masks
+
+ masks = tf.cond(num_instances > 0, resize_masks_branch,
+ reshape_masks_branch)
+ result.append(masks)
+
+ result.append(tf.stack([new_height, new_width, image_shape[2]]))
+ return result
+
+
+def subtract_channel_mean(image, means=None):
+ """Normalizes an image by subtracting a mean from each channel.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ means: float list containing a mean for each channel
+ Returns:
+ normalized_images: a tensor of shape [height, width, channels]
+ Raises:
+ ValueError: if images is not a 4D tensor or if the number of means is not
+ equal to the number of channels.
+ """
+ with tf.name_scope('SubtractChannelMean', values=[image, means]):
+ if len(image.get_shape()) != 3:
+ raise ValueError('Input must be of size [height, width, channels]')
+ if len(means) != image.get_shape()[-1]:
+ raise ValueError('len(means) must match the number of channels')
+ return image - [[means]]
+
+
+def one_hot_encoding(labels, num_classes=None):
+ """One-hot encodes the multiclass labels.
+
+ Example usage:
+ labels = tf.constant([1, 4], dtype=tf.int32)
+ one_hot = OneHotEncoding(labels, num_classes=5)
+ one_hot.eval() # evaluates to [0, 1, 0, 0, 1]
+
+ Args:
+ labels: A tensor of shape [None] corresponding to the labels.
+ num_classes: Number of classes in the dataset.
+ Returns:
+ onehot_labels: a tensor of shape [num_classes] corresponding to the one hot
+ encoding of the labels.
+ Raises:
+ ValueError: if num_classes is not specified.
+ """
+ with tf.name_scope('OneHotEncoding', values=[labels]):
+ if num_classes is None:
+ raise ValueError('num_classes must be specified')
+
+ labels = tf.one_hot(labels, num_classes, 1, 0)
+ return tf.reduce_max(labels, 0)
+
+
+def rgb_to_gray(image):
+ """Converts a 3 channel RGB image to a 1 channel grayscale image.
+
+ Args:
+ image: Rank 3 float32 tensor containing 1 image -> [height, width, 3]
+ with pixel values varying between [0, 1].
+
+ Returns:
+ image: A single channel grayscale image -> [image, height, 1].
+ """
+ return _rgb_to_grayscale(image)
+
+
+def random_self_concat_image(
+ image, boxes, labels, label_weights, label_confidences=None,
+ multiclass_scores=None, concat_vertical_probability=0.1,
+ concat_horizontal_probability=0.1, seed=None,
+ preprocess_vars_cache=None):
+ """Randomly concatenates the image with itself.
+
+ This function randomly concatenates the image with itself; the random
+ variables for vertical and horizontal concatenation are independent.
+ Afterwards, we adjust the old bounding boxes, and add new bounding boxes
+ for the new objects.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 containing the label weights.
+ label_confidences: (optional) rank 1 float32 containing the label
+ confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for
+ each box for each class.
+ concat_vertical_probability: (optional) a tf.float32 scalar denoting the
+ probability of a vertical concatenation.
+ concat_horizontal_probability: (optional) a tf.float32 scalar denoting the
+ probability of a horizontal concatenation.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ if label_confidences is not None also returns:
+ maybe_concat_label_confidences: cropped label weights.
+ if multiclass_scores is not None also returns:
+ maybe_concat_multiclass_scores: cropped_multiclass_scores.
+ """
+
+ concat_vertical = (tf.random_uniform([], seed=seed) <
+ concat_vertical_probability)
+ # Note the seed + 1 so we get some semblance of independence even with
+ # fixed seeds.
+ concat_horizontal = (tf.random_uniform([], seed=seed + 1 if seed else None)
+ < concat_horizontal_probability)
+
+ gen_func = lambda: (concat_vertical, concat_horizontal)
+ params = _get_or_create_preprocess_rand_vars(
+ gen_func, preprocessor_cache.PreprocessorCache.SELF_CONCAT_IMAGE,
+ preprocess_vars_cache)
+ concat_vertical, concat_horizontal = params
+
+ def _concat_image(image, boxes, labels, label_weights, axis):
+ """Concats the image to itself on `axis`."""
+ output_images = tf.concat([image, image], axis=axis)
+
+ if axis == 0:
+ # Concat vertically, so need to reduce the y coordinates.
+ old_scaling = tf.constant([0.5, 1.0, 0.5, 1.0])
+ new_translation = tf.constant([0.5, 0.0, 0.5, 0.0])
+ elif axis == 1:
+ old_scaling = tf.constant([1.0, 0.5, 1.0, 0.5])
+ new_translation = tf.constant([0.0, 0.5, 0.0, 0.5])
+
+ old_boxes = old_scaling * boxes
+ new_boxes = old_boxes + new_translation
+ all_boxes = tf.concat([old_boxes, new_boxes], axis=0)
+
+ return [output_images, all_boxes, tf.tile(labels, [2]), tf.tile(
+ label_weights, [2])]
+
+ image, boxes, labels, label_weights = tf.cond(
+ concat_vertical,
+ lambda: _concat_image(image, boxes, labels, label_weights, axis=0),
+ lambda: [image, boxes, labels, label_weights],
+ strict=True)
+
+ outputs = tf.cond(
+ concat_horizontal,
+ lambda: _concat_image(image, boxes, labels, label_weights, axis=1),
+ lambda: [image, boxes, labels, label_weights],
+ strict=True)
+
+ if label_confidences is not None:
+ label_confidences = tf.cond(concat_vertical,
+ lambda: tf.tile(label_confidences, [2]),
+ lambda: label_confidences)
+ outputs.append(tf.cond(concat_horizontal,
+ lambda: tf.tile(label_confidences, [2]),
+ lambda: label_confidences))
+
+ if multiclass_scores is not None:
+ multiclass_scores = tf.cond(concat_vertical,
+ lambda: tf.tile(multiclass_scores, [2, 1]),
+ lambda: multiclass_scores)
+ outputs.append(tf.cond(concat_horizontal,
+ lambda: tf.tile(multiclass_scores, [2, 1]),
+ lambda: multiclass_scores))
+
+ return outputs
+
+
+def ssd_random_crop(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio_range=((0.5, 2.0),) * 7,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 tensor containing the weights.
+ label_confidences: rank 1 float32 tensor containing the confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def random_crop_selector(selected_result, index):
+ """Applies random_crop_image to selected result.
+
+ Args:
+ selected_result: A tuple containing image, boxes, labels, keypoints (if
+ not None), and masks (if not None).
+ index: The index that was randomly selected.
+
+ Returns: A tuple containing image, boxes, labels, keypoints (if not None),
+ and masks (if not None).
+ """
+
+ i = 3
+ image, boxes, labels = selected_result[:i]
+ selected_label_weights = None
+ selected_label_confidences = None
+ selected_multiclass_scores = None
+ selected_masks = None
+ selected_keypoints = None
+ if label_weights is not None:
+ selected_label_weights = selected_result[i]
+ i += 1
+ if label_confidences is not None:
+ selected_label_confidences = selected_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ selected_multiclass_scores = selected_result[i]
+ i += 1
+ if masks is not None:
+ selected_masks = selected_result[i]
+ i += 1
+ if keypoints is not None:
+ selected_keypoints = selected_result[i]
+
+ return random_crop_image(
+ image=image,
+ boxes=boxes,
+ labels=labels,
+ label_weights=selected_label_weights,
+ label_confidences=selected_label_confidences,
+ multiclass_scores=selected_multiclass_scores,
+ masks=selected_masks,
+ keypoints=selected_keypoints,
+ min_object_covered=min_object_covered[index],
+ aspect_ratio_range=aspect_ratio_range[index],
+ area_range=area_range[index],
+ overlap_thresh=overlap_thresh[index],
+ clip_boxes=clip_boxes[index],
+ random_coef=random_coef[index],
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ result = _apply_with_random_selector_tuples(
+ tuple(
+ t for t in (image, boxes, labels, label_weights, label_confidences,
+ multiclass_scores, masks, keypoints) if t is not None),
+ random_crop_selector,
+ num_cases=len(min_object_covered),
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.SSD_CROP_SELECTOR_ID)
+ return result
+
+
+def ssd_random_crop_pad(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ min_object_covered=(0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio_range=((0.5, 2.0),) * 6,
+ area_range=((0.1, 1.0),) * 6,
+ overlap_thresh=(0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 6,
+ random_coef=(0.15,) * 6,
+ min_padded_size_ratio=((1.0, 1.0),) * 6,
+ max_padded_size_ratio=((2.0, 2.0),) * 6,
+ pad_color=(None,) * 6,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instances] representing the
+ confidences for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the randomly
+ cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ new_labels: new labels.
+ new_label_weights: new label weights.
+ """
+
+ def random_crop_pad_selector(image_boxes_labels, index):
+ """Random crop preprocessing helper."""
+ i = 3
+ image, boxes, labels = image_boxes_labels[:i]
+ selected_label_weights = None
+ selected_label_confidences = None
+ selected_multiclass_scores = None
+ if label_weights is not None:
+ selected_label_weights = image_boxes_labels[i]
+ i += 1
+ if label_confidences is not None:
+ selected_label_confidences = image_boxes_labels[i]
+ i += 1
+ if multiclass_scores is not None:
+ selected_multiclass_scores = image_boxes_labels[i]
+
+ return random_crop_pad_image(
+ image,
+ boxes,
+ labels,
+ label_weights=selected_label_weights,
+ label_confidences=selected_label_confidences,
+ multiclass_scores=selected_multiclass_scores,
+ min_object_covered=min_object_covered[index],
+ aspect_ratio_range=aspect_ratio_range[index],
+ area_range=area_range[index],
+ overlap_thresh=overlap_thresh[index],
+ clip_boxes=clip_boxes[index],
+ random_coef=random_coef[index],
+ min_padded_size_ratio=min_padded_size_ratio[index],
+ max_padded_size_ratio=max_padded_size_ratio[index],
+ pad_color=pad_color[index],
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ return _apply_with_random_selector_tuples(
+ tuple(t for t in (image, boxes, labels, label_weights, label_confidences,
+ multiclass_scores) if t is not None),
+ random_crop_pad_selector,
+ num_cases=len(min_object_covered),
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.SSD_CROP_PAD_SELECTOR_ID)
+
+
+def ssd_random_crop_fixed_aspect_ratio(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio=1.0,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ The only difference is that the aspect ratio of the crops are fixed.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidences for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio: aspect ratio of the cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If multiclass_scores, masks, or keypoints is not None, the function also
+ returns:
+
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ aspect_ratio_range = ((aspect_ratio, aspect_ratio),) * len(area_range)
+
+ crop_result = ssd_random_crop(
+ image,
+ boxes,
+ labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+ i = 3
+ new_image, new_boxes, new_labels = crop_result[:i]
+ new_label_weights = None
+ new_label_confidences = None
+ new_multiclass_scores = None
+ new_masks = None
+ new_keypoints = None
+ if label_weights is not None:
+ new_label_weights = crop_result[i]
+ i += 1
+ if label_confidences is not None:
+ new_label_confidences = crop_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ new_multiclass_scores = crop_result[i]
+ i += 1
+ if masks is not None:
+ new_masks = crop_result[i]
+ i += 1
+ if keypoints is not None:
+ new_keypoints = crop_result[i]
+
+ result = random_crop_to_aspect_ratio(
+ new_image,
+ new_boxes,
+ new_labels,
+ label_weights=new_label_weights,
+ label_confidences=new_label_confidences,
+ multiclass_scores=new_multiclass_scores,
+ masks=new_masks,
+ keypoints=new_keypoints,
+ aspect_ratio=aspect_ratio,
+ clip_boxes=clip_boxes,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ return result
+
+
+def ssd_random_crop_pad_fixed_aspect_ratio(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio=1.0,
+ aspect_ratio_range=((0.5, 2.0),) * 7,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop and pad preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ The only difference is that after the initial crop, images are zero-padded
+ to a fixed aspect ratio instead of being resized to that aspect ratio.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio: the final aspect ratio to pad to.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If multiclass_scores, masks, or keypoints is not None, the function also
+ returns:
+
+ multiclass_scores: rank 2 with shape [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ crop_result = ssd_random_crop(
+ image,
+ boxes,
+ labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+ i = 3
+ new_image, new_boxes, new_labels = crop_result[:i]
+ new_label_weights = None
+ new_label_confidences = None
+ new_multiclass_scores = None
+ new_masks = None
+ new_keypoints = None
+ if label_weights is not None:
+ new_label_weights = crop_result[i]
+ i += 1
+ if label_confidences is not None:
+ new_label_confidences = crop_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ new_multiclass_scores = crop_result[i]
+ i += 1
+ if masks is not None:
+ new_masks = crop_result[i]
+ i += 1
+ if keypoints is not None:
+ new_keypoints = crop_result[i]
+
+ result = random_pad_to_aspect_ratio(
+ new_image,
+ new_boxes,
+ masks=new_masks,
+ keypoints=new_keypoints,
+ aspect_ratio=aspect_ratio,
+ min_padded_size_ratio=min_padded_size_ratio,
+ max_padded_size_ratio=max_padded_size_ratio,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ result = list(result)
+ i = 3
+ result.insert(2, new_labels)
+ if new_label_weights is not None:
+ result.insert(i, new_label_weights)
+ i += 1
+ if new_label_confidences is not None:
+ result.insert(i, new_label_confidences)
+ i += 1
+ if multiclass_scores is not None:
+ result.insert(i, new_multiclass_scores)
+ result = tuple(result)
+
+ return result
+
+
+def convert_class_logits_to_softmax(multiclass_scores, temperature=1.0):
+ """Converts multiclass logits to softmax scores after applying temperature.
+
+ Args:
+ multiclass_scores: float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ temperature: Scale factor to use prior to applying softmax. Larger
+ temperatures give more uniform distruibutions after softmax.
+
+ Returns:
+ multiclass_scores: float32 tensor of shape
+ [num_instances, num_classes] with scaling and softmax applied.
+ """
+
+ # Multiclass scores must be stored as logits. Apply temp and softmax.
+ multiclass_scores_scaled = tf.divide(
+ multiclass_scores, temperature, name='scale_logits')
+ multiclass_scores = tf.nn.softmax(multiclass_scores_scaled, name='softmax')
+
+ return multiclass_scores
+
+
+def get_default_func_arg_map(include_label_weights=True,
+ include_label_confidences=False,
+ include_multiclass_scores=False,
+ include_instance_masks=False,
+ include_keypoints=False):
+ """Returns the default mapping from a preprocessor function to its args.
+
+ Args:
+ include_label_weights: If True, preprocessing functions will modify the
+ label weights, too.
+ include_label_confidences: If True, preprocessing functions will modify the
+ label confidences, too.
+ include_multiclass_scores: If True, preprocessing functions will modify the
+ multiclass scores, too.
+ include_instance_masks: If True, preprocessing functions will modify the
+ instance masks, too.
+ include_keypoints: If True, preprocessing functions will modify the
+ keypoints, too.
+
+ Returns:
+ A map from preprocessing functions to the arguments they receive.
+ """
+ groundtruth_label_weights = None
+ if include_label_weights:
+ groundtruth_label_weights = (
+ fields.InputDataFields.groundtruth_weights)
+
+ groundtruth_label_confidences = None
+ if include_label_confidences:
+ groundtruth_label_confidences = (
+ fields.InputDataFields.groundtruth_confidences)
+
+ multiclass_scores = None
+ if include_multiclass_scores:
+ multiclass_scores = (fields.InputDataFields.multiclass_scores)
+
+ groundtruth_instance_masks = None
+ if include_instance_masks:
+ groundtruth_instance_masks = (
+ fields.InputDataFields.groundtruth_instance_masks)
+
+ groundtruth_keypoints = None
+ if include_keypoints:
+ groundtruth_keypoints = fields.InputDataFields.groundtruth_keypoints
+
+ prep_func_arg_map = {
+ normalize_image: (fields.InputDataFields.image,),
+ random_horizontal_flip: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_vertical_flip: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_rotation90: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_pixel_value_scale: (fields.InputDataFields.image,),
+ random_image_scale: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ random_rgb_to_gray: (fields.InputDataFields.image,),
+ random_adjust_brightness: (fields.InputDataFields.image,),
+ random_adjust_contrast: (fields.InputDataFields.image,),
+ random_adjust_hue: (fields.InputDataFields.image,),
+ random_adjust_saturation: (fields.InputDataFields.image,),
+ random_distort_color: (fields.InputDataFields.image,),
+ random_jitter_boxes: (fields.InputDataFields.groundtruth_boxes,),
+ random_crop_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ random_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_keypoints),
+ random_absolute_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes),
+ random_crop_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ random_crop_to_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_pad_to_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_black_patches: (fields.InputDataFields.image,),
+ random_jpeg_quality: (fields.InputDataFields.image,),
+ random_downscale_to_target_pixels: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ random_patch_gaussian: (fields.InputDataFields.image,),
+ autoaugment_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,),
+ retain_boxes_above_threshold: (
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ drop_label_probabilistically: (
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ remap_labels: (fields.InputDataFields.groundtruth_classes,),
+ image_to_float: (fields.InputDataFields.image,),
+ random_resize_method: (fields.InputDataFields.image,),
+ resize_to_range: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ resize_to_min_dimension: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ scale_boxes_to_pixel_coordinates: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_keypoints,
+ ),
+ resize_image: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ subtract_channel_mean: (fields.InputDataFields.image,),
+ one_hot_encoding: (fields.InputDataFields.groundtruth_image_classes,),
+ rgb_to_gray: (fields.InputDataFields.image,),
+ random_self_concat_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ ssd_random_crop: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ ssd_random_crop_pad: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ ssd_random_crop_fixed_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ ssd_random_crop_pad_fixed_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ convert_class_logits_to_softmax: (multiclass_scores,),
+ }
+
+ return prep_func_arg_map
+
+
+def preprocess(tensor_dict,
+ preprocess_options,
+ func_arg_map=None,
+ preprocess_vars_cache=None):
+ """Preprocess images and bounding boxes.
+
+ Various types of preprocessing (to be implemented) based on the
+ preprocess_options dictionary e.g. "crop image" (affects image and possibly
+ boxes), "white balance image" (affects only image), etc. If self._options
+ is None, no preprocessing is done.
+
+ Args:
+ tensor_dict: dictionary that contains images, boxes, and can contain other
+ things as well.
+ images-> rank 4 float32 tensor contains
+ 1 image -> [1, height, width, 3].
+ with pixel values varying between [0, 1]
+ boxes-> rank 2 float32 tensor containing
+ the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning
+ their coordinates vary between [0, 1].
+ Each row is in the form
+ of [ymin, xmin, ymax, xmax].
+ preprocess_options: It is a list of tuples, where each tuple contains a
+ function and a dictionary that contains arguments and
+ their values.
+ func_arg_map: mapping from preprocessing functions to arguments that they
+ expect to receive and return.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ tensor_dict: which contains the preprocessed images, bounding boxes, etc.
+
+ Raises:
+ ValueError: (a) If the functions passed to Preprocess
+ are not in func_arg_map.
+ (b) If the arguments that a function needs
+ do not exist in tensor_dict.
+ (c) If image in tensor_dict is not rank 4
+ """
+ if func_arg_map is None:
+ func_arg_map = get_default_func_arg_map()
+
+ # changes the images to image (rank 4 to rank 3) since the functions
+ # receive rank 3 tensor for image
+ if fields.InputDataFields.image in tensor_dict:
+ images = tensor_dict[fields.InputDataFields.image]
+ if len(images.get_shape()) != 4:
+ raise ValueError('images in tensor_dict should be rank 4')
+ image = tf.squeeze(images, axis=0)
+ tensor_dict[fields.InputDataFields.image] = image
+
+ # Preprocess inputs based on preprocess_options
+ for option in preprocess_options:
+ func, params = option
+ if func not in func_arg_map:
+ raise ValueError('The function %s does not exist in func_arg_map' %
+ (func.__name__))
+ arg_names = func_arg_map[func]
+ for a in arg_names:
+ if a is not None and a not in tensor_dict:
+ raise ValueError('The function %s requires argument %s' %
+ (func.__name__, a))
+
+ def get_arg(key):
+ return tensor_dict[key] if key is not None else None
+
+ args = [get_arg(a) for a in arg_names]
+ if preprocess_vars_cache is not None:
+ if six.PY2:
+ # pylint: disable=deprecated-method
+ arg_spec = inspect.getargspec(func)
+ # pylint: enable=deprecated-method
+ else:
+ arg_spec = inspect.getfullargspec(func)
+ if 'preprocess_vars_cache' in arg_spec.args:
+ params['preprocess_vars_cache'] = preprocess_vars_cache
+
+ results = func(*args, **params)
+ if not isinstance(results, (list, tuple)):
+ results = (results,)
+ # Removes None args since the return values will not contain those.
+ arg_names = [arg_name for arg_name in arg_names if arg_name is not None]
+ for res, arg_name in zip(results, arg_names):
+ tensor_dict[arg_name] = res
+
+ # changes the image to images (rank 3 to rank 4) to be compatible to what
+ # we received in the first place
+ if fields.InputDataFields.image in tensor_dict:
+ image = tensor_dict[fields.InputDataFields.image]
+ images = tf.expand_dims(image, 0)
+ tensor_dict[fields.InputDataFields.image] = images
+
+ return tensor_dict
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_cache.py b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_cache.py
new file mode 100644
index 00000000..706d44cd
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_cache.py
@@ -0,0 +1,107 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Records previous preprocessing operations and allows them to be repeated.
+
+Used with object_detection.core.preprocessor. Passing a PreprocessorCache
+into individual data augmentation functions or the general preprocess() function
+will store all randomly generated variables in the PreprocessorCache. When
+a preprocessor function is called multiple times with the same
+PreprocessorCache object, that function will perform the same augmentation
+on all calls.
+"""
+
+from collections import defaultdict
+
+
+class PreprocessorCache(object):
+ """Dictionary wrapper storing random variables generated during preprocessing.
+ """
+
+ # Constant keys representing different preprocessing functions
+ ROTATION90 = 'rotation90'
+ HORIZONTAL_FLIP = 'horizontal_flip'
+ VERTICAL_FLIP = 'vertical_flip'
+ PIXEL_VALUE_SCALE = 'pixel_value_scale'
+ IMAGE_SCALE = 'image_scale'
+ RGB_TO_GRAY = 'rgb_to_gray'
+ ADJUST_BRIGHTNESS = 'adjust_brightness'
+ ADJUST_CONTRAST = 'adjust_contrast'
+ ADJUST_HUE = 'adjust_hue'
+ ADJUST_SATURATION = 'adjust_saturation'
+ DISTORT_COLOR = 'distort_color'
+ STRICT_CROP_IMAGE = 'strict_crop_image'
+ CROP_IMAGE = 'crop_image'
+ PAD_IMAGE = 'pad_image'
+ CROP_TO_ASPECT_RATIO = 'crop_to_aspect_ratio'
+ RESIZE_METHOD = 'resize_method'
+ PAD_TO_ASPECT_RATIO = 'pad_to_aspect_ratio'
+ BLACK_PATCHES = 'black_patches'
+ ADD_BLACK_PATCH = 'add_black_patch'
+ SELECTOR = 'selector'
+ SELECTOR_TUPLES = 'selector_tuples'
+ SELF_CONCAT_IMAGE = 'self_concat_image'
+ SSD_CROP_SELECTOR_ID = 'ssd_crop_selector_id'
+ SSD_CROP_PAD_SELECTOR_ID = 'ssd_crop_pad_selector_id'
+ JPEG_QUALITY = 'jpeg_quality'
+ DOWNSCALE_TO_TARGET_PIXELS = 'downscale_to_target_pixels'
+ PATCH_GAUSSIAN = 'patch_gaussian'
+
+ # 27 permitted function ids
+ _VALID_FNS = [ROTATION90, HORIZONTAL_FLIP, VERTICAL_FLIP, PIXEL_VALUE_SCALE,
+ IMAGE_SCALE, RGB_TO_GRAY, ADJUST_BRIGHTNESS, ADJUST_CONTRAST,
+ ADJUST_HUE, ADJUST_SATURATION, DISTORT_COLOR, STRICT_CROP_IMAGE,
+ CROP_IMAGE, PAD_IMAGE, CROP_TO_ASPECT_RATIO, RESIZE_METHOD,
+ PAD_TO_ASPECT_RATIO, BLACK_PATCHES, ADD_BLACK_PATCH, SELECTOR,
+ SELECTOR_TUPLES, SELF_CONCAT_IMAGE, SSD_CROP_SELECTOR_ID,
+ SSD_CROP_PAD_SELECTOR_ID, JPEG_QUALITY,
+ DOWNSCALE_TO_TARGET_PIXELS, PATCH_GAUSSIAN]
+
+ def __init__(self):
+ self._history = defaultdict(dict)
+
+ def clear(self):
+ """Resets cache."""
+ self._history = defaultdict(dict)
+
+ def get(self, function_id, key):
+ """Gets stored value given a function id and key.
+
+ Args:
+ function_id: identifier for the preprocessing function used.
+ key: identifier for the variable stored.
+ Returns:
+ value: the corresponding value, expected to be a tensor or
+ nested structure of tensors.
+ Raises:
+ ValueError: if function_id is not one of the 23 valid function ids.
+ """
+ if function_id not in self._VALID_FNS:
+ raise ValueError('Function id not recognized: %s.' % str(function_id))
+ return self._history[function_id].get(key)
+
+ def update(self, function_id, key, value):
+ """Adds a value to the dictionary.
+
+ Args:
+ function_id: identifier for the preprocessing function used.
+ key: identifier for the variable stored.
+ value: the value to store, expected to be a tensor or nested structure
+ of tensors.
+ Raises:
+ ValueError: if function_id is not one of the 23 valid function ids.
+ """
+ if function_id not in self._VALID_FNS:
+ raise ValueError('Function id not recognized: %s.' % str(function_id))
+ self._history[function_id][key] = value
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_test.py b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_test.py
new file mode 100644
index 00000000..39167742
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/preprocessor_test.py
@@ -0,0 +1,3585 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.preprocessor."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from absl.testing import parameterized
+import numpy as np
+import six
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import preprocessor
+from object_detection.core import preprocessor_cache
+from object_detection.core import standard_fields as fields
+
+if six.PY2:
+ import mock # pylint: disable=g-import-not-at-top
+else:
+ from unittest import mock # pylint: disable=g-import-not-at-top
+
+
+class PreprocessorTest(tf.test.TestCase, parameterized.TestCase):
+
+ def createColorfulTestImage(self):
+ ch255 = tf.fill([1, 100, 200, 1], tf.constant(255, dtype=tf.uint8))
+ ch128 = tf.fill([1, 100, 200, 1], tf.constant(128, dtype=tf.uint8))
+ ch0 = tf.fill([1, 100, 200, 1], tf.constant(0, dtype=tf.uint8))
+ imr = tf.concat([ch255, ch0, ch0], 3)
+ img = tf.concat([ch255, ch255, ch0], 3)
+ imb = tf.concat([ch255, ch0, ch255], 3)
+ imw = tf.concat([ch128, ch128, ch128], 3)
+ imu = tf.concat([imr, img], 2)
+ imd = tf.concat([imb, imw], 2)
+ im = tf.concat([imu, imd], 1)
+ return im
+
+ def createTestImages(self):
+ images_r = tf.constant([[[128, 128, 128, 128], [0, 0, 128, 128],
+ [0, 128, 128, 128], [192, 192, 128, 128]]],
+ dtype=tf.uint8)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, 128, 128], [0, 0, 128, 128],
+ [0, 128, 192, 192], [192, 192, 128, 192]]],
+ dtype=tf.uint8)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[128, 128, 192, 0], [0, 0, 128, 192],
+ [0, 128, 128, 0], [192, 192, 192, 128]]],
+ dtype=tf.uint8)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def createEmptyTestBoxes(self):
+ boxes = tf.constant([[]], dtype=tf.float32)
+ return boxes
+
+ def createTestBoxes(self):
+ boxes = tf.constant(
+ [[0.0, 0.25, 0.75, 1.0], [0.25, 0.5, 0.75, 1.0]], dtype=tf.float32)
+ return boxes
+
+ def createTestGroundtruthWeights(self):
+ return tf.constant([1.0, 0.5], dtype=tf.float32)
+
+ def createTestMasks(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]],
+ [[255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def createTestKeypoints(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createTestKeypointsInsideCrop(self):
+ keypoints = np.array([
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createTestKeypointsOutsideCrop(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createKeypointFlipPermutation(self):
+ return np.array([0, 2, 1], dtype=np.int32)
+
+ def createTestLabels(self):
+ labels = tf.constant([1, 2], dtype=tf.int32)
+ return labels
+
+ def createTestLabelsLong(self):
+ labels = tf.constant([1, 2, 4], dtype=tf.int32)
+ return labels
+
+ def createTestBoxesOutOfImage(self):
+ boxes = tf.constant(
+ [[-0.1, 0.25, 0.75, 1], [0.25, 0.5, 0.75, 1.1]], dtype=tf.float32)
+ return boxes
+
+ def createTestMultiClassScores(self):
+ return tf.constant([[1.0, 0.0], [0.5, 0.5]], dtype=tf.float32)
+
+ def expectedImagesAfterNormalization(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [-1, -1, 0, 0],
+ [-1, 0, 0, 0], [0.5, 0.5, 0, 0]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-1, -1, 0, 0], [-1, -1, 0, 0],
+ [-1, 0, 0.5, 0.5], [0.5, 0.5, 0, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0, 0, 0.5, -1], [-1, -1, 0, 0.5],
+ [-1, 0, 0, -1], [0.5, 0.5, 0.5, 0]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedMaxImageAfterColorScale(self):
+ images_r = tf.constant([[[0.1, 0.1, 0.1, 0.1], [-0.9, -0.9, 0.1, 0.1],
+ [-0.9, 0.1, 0.1, 0.1], [0.6, 0.6, 0.1, 0.1]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-0.9, -0.9, 0.1, 0.1], [-0.9, -0.9, 0.1, 0.1],
+ [-0.9, 0.1, 0.6, 0.6], [0.6, 0.6, 0.1, 0.6]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0.1, 0.1, 0.6, -0.9], [-0.9, -0.9, 0.1, 0.6],
+ [-0.9, 0.1, 0.1, -0.9], [0.6, 0.6, 0.6, 0.1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedMinImageAfterColorScale(self):
+ images_r = tf.constant([[[-0.1, -0.1, -0.1, -0.1], [-1, -1, -0.1, -0.1],
+ [-1, -0.1, -0.1, -0.1], [0.4, 0.4, -0.1, -0.1]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-1, -1, -0.1, -0.1], [-1, -1, -0.1, -0.1],
+ [-1, -0.1, 0.4, 0.4], [0.4, 0.4, -0.1, 0.4]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-0.1, -0.1, 0.4, -1], [-1, -1, -0.1, 0.4],
+ [-1, -0.1, -0.1, -1], [0.4, 0.4, 0.4, -0.1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterLeftRightFlip(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [0, 0, -1, -1],
+ [0, 0, 0, -1], [0, 0, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, -1, -1], [0, 0, -1, -1],
+ [0.5, 0.5, 0, -1], [0.5, 0, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-1, 0.5, 0, 0], [0.5, 0, -1, -1],
+ [-1, 0, 0, -1], [0, 0.5, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterUpDownFlip(self):
+ images_r = tf.constant([[[0.5, 0.5, 0, 0], [-1, 0, 0, 0],
+ [-1, -1, 0, 0], [0, 0, 0, 0]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0.5, 0.5, 0, 0.5], [-1, 0, 0.5, 0.5],
+ [-1, -1, 0, 0], [-1, -1, 0, 0]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0.5, 0.5, 0.5, 0], [-1, 0, 0, -1],
+ [-1, -1, 0, 0.5], [0, 0, 0.5, -1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterRot90(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [0, 0, 0, 0],
+ [0, -1, 0, 0.5], [0, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, 0.5, 0.5], [0, 0, 0.5, 0],
+ [-1, -1, 0, 0.5], [-1, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-1, 0.5, -1, 0], [0.5, 0, 0, 0.5],
+ [0, -1, 0, 0.5], [0, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedBoxesAfterLeftRightFlip(self):
+ boxes = tf.constant([[0.0, 0.0, 0.75, 0.75], [0.25, 0.0, 0.75, 0.5]],
+ dtype=tf.float32)
+ return boxes
+
+ def expectedBoxesAfterUpDownFlip(self):
+ boxes = tf.constant([[0.25, 0.25, 1.0, 1.0], [0.25, 0.5, 0.75, 1.0]],
+ dtype=tf.float32)
+ return boxes
+
+ def expectedBoxesAfterRot90(self):
+ boxes = tf.constant(
+ [[0.0, 0.0, 0.75, 0.75], [0.0, 0.25, 0.5, 0.75]], dtype=tf.float32)
+ return boxes
+
+ def expectedMasksAfterLeftRightFlip(self):
+ mask = np.array([
+ [[0.0, 0.0, 255.0],
+ [0.0, 0.0, 255.0],
+ [0.0, 0.0, 255.0]],
+ [[0.0, 255.0, 255.0],
+ [0.0, 255.0, 255.0],
+ [0.0, 255.0, 255.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedMasksAfterUpDownFlip(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]],
+ [[255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedMasksAfterRot90(self):
+ mask = np.array([
+ [[0.0, 0.0, 0.0],
+ [0.0, 0.0, 0.0],
+ [255.0, 255.0, 255.0]],
+ [[0.0, 0.0, 0.0],
+ [255.0, 255.0, 255.0],
+ [255.0, 255.0, 255.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedLabelScoresAfterThresholding(self):
+ return tf.constant([1.0], dtype=tf.float32)
+
+ def expectedBoxesAfterThresholding(self):
+ return tf.constant([[0.0, 0.25, 0.75, 1.0]], dtype=tf.float32)
+
+ def expectedLabelsAfterThresholding(self):
+ return tf.constant([1], dtype=tf.float32)
+
+ def expectedMultiClassScoresAfterThresholding(self):
+ return tf.constant([[1.0, 0.0]], dtype=tf.float32)
+
+ def expectedMasksAfterThresholding(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedKeypointsAfterThresholding(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]]
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def expectedLabelScoresAfterThresholdingWithMissingScore(self):
+ return tf.constant([np.nan], dtype=tf.float32)
+
+ def expectedBoxesAfterThresholdingWithMissingScore(self):
+ return tf.constant([[0.25, 0.5, 0.75, 1]], dtype=tf.float32)
+
+ def expectedLabelsAfterThresholdingWithMissingScore(self):
+ return tf.constant([2], dtype=tf.float32)
+
+ def expectedLabelScoresAfterDropping(self):
+ return tf.constant([0.5], dtype=tf.float32)
+
+ def expectedBoxesAfterDropping(self):
+ return tf.constant([[0.25, 0.5, 0.75, 1.0]], dtype=tf.float32)
+
+ def expectedLabelsAfterDropping(self):
+ return tf.constant([2], dtype=tf.float32)
+
+ def expectedMultiClassScoresAfterDropping(self):
+ return tf.constant([[0.5, 0.5]], dtype=tf.float32)
+
+ def expectedMasksAfterDropping(self):
+ masks = np.array([[[255.0, 255.0, 0.0], [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(masks, dtype=tf.float32)
+
+ def expectedKeypointsAfterDropping(self):
+ keypoints = np.array([[[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def expectedLabelsAfterRemapping(self):
+ return tf.constant([3, 3, 4], dtype=tf.float32)
+
+ def testRgbToGrayscale(self):
+ images = self.createTestImages()
+ grayscale_images = preprocessor._rgb_to_grayscale(images)
+ expected_images = tf.image.rgb_to_grayscale(images)
+ with self.test_session() as sess:
+ (grayscale_images, expected_images) = sess.run(
+ [grayscale_images, expected_images])
+ self.assertAllEqual(expected_images, grayscale_images)
+
+ def testNormalizeImage(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 256,
+ 'target_minval': -1,
+ 'target_maxval': 1
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ images_expected = self.expectedImagesAfterNormalization()
+
+ with self.test_session() as sess:
+ (images_, images_expected_) = sess.run(
+ [images, images_expected])
+ images_shape_ = images_.shape
+ images_expected_shape_ = images_expected_.shape
+ expected_shape = [1, 4, 4, 3]
+ self.assertAllEqual(images_expected_shape_, images_shape_)
+ self.assertAllEqual(images_shape_, expected_shape)
+ self.assertAllClose(images_, images_expected_)
+
+ def testRetainBoxesAboveThreshold(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (retained_boxes, retained_labels,
+ retained_weights) = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, threshold=0.6)
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_, retained_weights_,
+ expected_retained_boxes_, expected_retained_labels_,
+ expected_retained_weights_) = sess.run([
+ retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterThresholding(),
+ self.expectedLabelsAfterThresholding(),
+ self.expectedLabelScoresAfterThresholding()])
+ self.assertAllClose(
+ retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(
+ retained_labels_, expected_retained_labels_)
+ self.assertAllClose(
+ retained_weights_, expected_retained_weights_)
+
+ def testRetainBoxesAboveThresholdWithMultiClassScores(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+ (_, _, _,
+ retained_multiclass_scores) = preprocessor.retain_boxes_above_threshold(
+ boxes,
+ labels,
+ weights,
+ multiclass_scores=multiclass_scores,
+ threshold=0.6)
+ with self.test_session() as sess:
+ (retained_multiclass_scores_,
+ expected_retained_multiclass_scores_) = sess.run([
+ retained_multiclass_scores,
+ self.expectedMultiClassScoresAfterThresholding()
+ ])
+
+ self.assertAllClose(retained_multiclass_scores_,
+ expected_retained_multiclass_scores_)
+
+ def testRetainBoxesAboveThresholdWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+ _, _, _, retained_masks = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, masks, threshold=0.6)
+ with self.test_session() as sess:
+ retained_masks_, expected_retained_masks_ = sess.run([
+ retained_masks, self.expectedMasksAfterThresholding()])
+
+ self.assertAllClose(
+ retained_masks_, expected_retained_masks_)
+
+ def testRetainBoxesAboveThresholdWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ (_, _, _, retained_keypoints) = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, keypoints=keypoints, threshold=0.6)
+ with self.test_session() as sess:
+ (retained_keypoints_,
+ expected_retained_keypoints_) = sess.run([
+ retained_keypoints,
+ self.expectedKeypointsAfterThresholding()])
+
+ self.assertAllClose(
+ retained_keypoints_, expected_retained_keypoints_)
+
+ def testDropLabelProbabilistically(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (retained_boxes, retained_labels,
+ retained_weights) = preprocessor.drop_label_probabilistically(
+ boxes, labels, weights, dropped_label=1, drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_, retained_weights_,
+ expected_retained_boxes_, expected_retained_labels_,
+ expected_retained_weights_) = sess.run([
+ retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterDropping(),
+ self.expectedLabelsAfterDropping(),
+ self.expectedLabelScoresAfterDropping()
+ ])
+ self.assertAllClose(retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(retained_labels_, expected_retained_labels_)
+ self.assertAllClose(retained_weights_, expected_retained_weights_)
+
+ def testDropLabelProbabilisticallyWithProbabilityHalf(self):
+ # Boxes contain one box of label 2 and one box of label 1 which should be
+ # dropped ~50% of the time.
+ num_tests = 100
+ total = 0
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (_, retained_labels, _) = preprocessor.drop_label_probabilistically(
+ boxes, labels, weights, dropped_label=1, drop_probability=0.5)
+ for _ in range(num_tests):
+ with self.test_session() as sess:
+ retained_labels_ = sess.run(retained_labels)
+ total += len(retained_labels_)
+ self.assertIn(2, retained_labels_)
+ av = total * 1.0 / num_tests
+ self.assertGreater(av, 1.40)
+ self.assertLess(av, 1.50)
+
+ def testDropLabelProbabilisticallyWithMultiClassScores(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+ (_, _, _,
+ retained_multiclass_scores) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ multiclass_scores=multiclass_scores,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_multiclass_scores_,
+ expected_retained_multiclass_scores_) = sess.run([
+ retained_multiclass_scores,
+ self.expectedMultiClassScoresAfterDropping()
+ ])
+ self.assertAllClose(retained_multiclass_scores_,
+ expected_retained_multiclass_scores_)
+
+ def testDropLabelProbabilisticallyWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+ (_, _, _, retained_masks) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ masks=masks,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_masks_, expected_retained_masks_) = sess.run(
+ [retained_masks, self.expectedMasksAfterDropping()])
+ self.assertAllClose(retained_masks_, expected_retained_masks_)
+
+ def testDropLabelProbabilisticallyWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ (_, _, _, retained_keypoints) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ keypoints=keypoints,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_keypoints_, expected_retained_keypoints_) = sess.run(
+ [retained_keypoints,
+ self.expectedKeypointsAfterDropping()])
+ self.assertAllClose(retained_keypoints_, expected_retained_keypoints_)
+
+ def testRemapLabels(self):
+ labels = self.createTestLabelsLong()
+ remapped_labels = preprocessor.remap_labels(labels, [1, 2], 3)
+ with self.test_session() as sess:
+ (remapped_labels_, expected_remapped_labels_) = sess.run(
+ [remapped_labels, self.expectedLabelsAfterRemapping()])
+ self.assertAllClose(remapped_labels_, expected_remapped_labels_)
+
+ def testFlipBoxesLeftRight(self):
+ boxes = self.createTestBoxes()
+ flipped_boxes = preprocessor._flip_boxes_left_right(boxes)
+ expected_boxes = self.expectedBoxesAfterLeftRightFlip()
+ with self.test_session() as sess:
+ flipped_boxes, expected_boxes = sess.run([flipped_boxes, expected_boxes])
+ self.assertAllEqual(flipped_boxes.flatten(), expected_boxes.flatten())
+
+ def testFlipBoxesUpDown(self):
+ boxes = self.createTestBoxes()
+ flipped_boxes = preprocessor._flip_boxes_up_down(boxes)
+ expected_boxes = self.expectedBoxesAfterUpDownFlip()
+ with self.test_session() as sess:
+ flipped_boxes, expected_boxes = sess.run([flipped_boxes, expected_boxes])
+ self.assertAllEqual(flipped_boxes.flatten(), expected_boxes.flatten())
+
+ def testRot90Boxes(self):
+ boxes = self.createTestBoxes()
+ rotated_boxes = preprocessor._rot90_boxes(boxes)
+ expected_boxes = self.expectedBoxesAfterRot90()
+ with self.test_session() as sess:
+ rotated_boxes, expected_boxes = sess.run([rotated_boxes, expected_boxes])
+ self.assertAllEqual(rotated_boxes.flatten(), expected_boxes.flatten())
+
+ def testFlipMasksLeftRight(self):
+ test_mask = self.createTestMasks()
+ flipped_mask = preprocessor._flip_masks_left_right(test_mask)
+ expected_mask = self.expectedMasksAfterLeftRightFlip()
+ with self.test_session() as sess:
+ flipped_mask, expected_mask = sess.run([flipped_mask, expected_mask])
+ self.assertAllEqual(flipped_mask.flatten(), expected_mask.flatten())
+
+ def testFlipMasksUpDown(self):
+ test_mask = self.createTestMasks()
+ flipped_mask = preprocessor._flip_masks_up_down(test_mask)
+ expected_mask = self.expectedMasksAfterUpDownFlip()
+ with self.test_session() as sess:
+ flipped_mask, expected_mask = sess.run([flipped_mask, expected_mask])
+ self.assertAllEqual(flipped_mask.flatten(), expected_mask.flatten())
+
+ def testRot90Masks(self):
+ test_mask = self.createTestMasks()
+ rotated_mask = preprocessor._rot90_masks(test_mask)
+ expected_mask = self.expectedMasksAfterRot90()
+ with self.test_session() as sess:
+ rotated_mask, expected_mask = sess.run([rotated_mask, expected_mask])
+ self.assertAllEqual(rotated_mask.flatten(), expected_mask.flatten())
+
+ def _testPreprocessorCache(self,
+ preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False,
+ num_runs=4):
+ cache = preprocessor_cache.PreprocessorCache()
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ weights = self.createTestGroundtruthWeights()
+ classes = self.createTestLabels()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=test_masks, include_keypoints=test_keypoints)
+ out = []
+ for i in range(num_runs):
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ num_outputs = 1
+ if test_boxes:
+ tensor_dict[fields.InputDataFields.groundtruth_boxes] = boxes
+ tensor_dict[fields.InputDataFields.groundtruth_classes] = classes
+ num_outputs += 1
+ if test_masks:
+ tensor_dict[fields.InputDataFields.groundtruth_instance_masks] = masks
+ num_outputs += 1
+ if test_keypoints:
+ tensor_dict[fields.InputDataFields.groundtruth_keypoints] = keypoints
+ num_outputs += 1
+ out.append(preprocessor.preprocess(
+ tensor_dict, preprocess_options, preprocessor_arg_map, cache))
+
+ with self.test_session() as sess:
+ to_run = []
+ for i in range(num_runs):
+ to_run.append(out[i][fields.InputDataFields.image])
+ if test_boxes:
+ to_run.append(out[i][fields.InputDataFields.groundtruth_boxes])
+ if test_masks:
+ to_run.append(
+ out[i][fields.InputDataFields.groundtruth_instance_masks])
+ if test_keypoints:
+ to_run.append(out[i][fields.InputDataFields.groundtruth_keypoints])
+
+ out_array = sess.run(to_run)
+ for i in range(num_outputs, len(out_array)):
+ self.assertAllClose(out_array[i], out_array[i - num_outputs])
+
+ def testRandomHorizontalFlip(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterLeftRightFlip()
+ boxes_expected1 = self.expectedBoxesAfterLeftRightFlip()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomHorizontalFlipWithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterLeftRightFlip()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomHorizontalFlipWithCache(self):
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ preprocess_options = [
+ (preprocessor.random_horizontal_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomHorizontalFlipWithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocess_options = [
+ (preprocessor.random_horizontal_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomVerticalFlip(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterUpDownFlip()
+ boxes_expected1 = self.expectedBoxesAfterUpDownFlip()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomVerticalFlipWithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterUpDownFlip()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomVerticalFlipWithCache(self):
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ preprocess_options = [
+ (preprocessor.random_vertical_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomVerticalFlipWithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocess_options = [
+ (preprocessor.random_vertical_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomRotation90(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterRot90()
+ boxes_expected1 = self.expectedBoxesAfterRot90()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomRotation90WithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterRot90()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomRotation90WithCache(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomRotation90WithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomPixelValueScale(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_pixel_value_scale, {}))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_min = tf.cast(images, dtype=tf.float32) * 0.9 / 255.0
+ images_max = tf.cast(images, dtype=tf.float32) * 1.1 / 255.0
+ images = tensor_dict[fields.InputDataFields.image]
+ values_greater = tf.greater_equal(images, images_min)
+ values_less = tf.less_equal(images, images_max)
+ values_true = tf.fill([1, 4, 4, 3], True)
+ with self.test_session() as sess:
+ (values_greater_, values_less_, values_true_) = sess.run(
+ [values_greater, values_less, values_true])
+ self.assertAllClose(values_greater_, values_true_)
+ self.assertAllClose(values_less_, values_true_)
+
+ def testRandomPixelValueScaleWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_pixel_value_scale, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomImageScale(self):
+ preprocess_options = [(preprocessor.random_image_scale, {})]
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images_scaled = tensor_dict[fields.InputDataFields.image]
+ images_original_shape = tf.shape(images_original)
+ images_scaled_shape = tf.shape(images_scaled)
+ with self.test_session() as sess:
+ (images_original_shape_, images_scaled_shape_) = sess.run(
+ [images_original_shape, images_scaled_shape])
+ self.assertTrue(
+ images_original_shape_[1] * 0.5 <= images_scaled_shape_[1])
+ self.assertTrue(
+ images_original_shape_[1] * 2.0 >= images_scaled_shape_[1])
+ self.assertTrue(
+ images_original_shape_[2] * 0.5 <= images_scaled_shape_[2])
+ self.assertTrue(
+ images_original_shape_[2] * 2.0 >= images_scaled_shape_[2])
+
+ def testRandomImageScaleWithCache(self):
+ preprocess_options = [(preprocessor.random_image_scale, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomRGBtoGray(self):
+ preprocess_options = [(preprocessor.random_rgb_to_gray, {})]
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images_gray = tensor_dict[fields.InputDataFields.image]
+ images_gray_r, images_gray_g, images_gray_b = tf.split(
+ value=images_gray, num_or_size_splits=3, axis=3)
+ images_r, images_g, images_b = tf.split(
+ value=images_original, num_or_size_splits=3, axis=3)
+ images_r_diff1 = tf.squared_difference(
+ tf.cast(images_r, dtype=tf.float32),
+ tf.cast(images_gray_r, dtype=tf.float32))
+ images_r_diff2 = tf.squared_difference(
+ tf.cast(images_gray_r, dtype=tf.float32),
+ tf.cast(images_gray_g, dtype=tf.float32))
+ images_r_diff = tf.multiply(images_r_diff1, images_r_diff2)
+ images_g_diff1 = tf.squared_difference(
+ tf.cast(images_g, dtype=tf.float32),
+ tf.cast(images_gray_g, dtype=tf.float32))
+ images_g_diff2 = tf.squared_difference(
+ tf.cast(images_gray_g, dtype=tf.float32),
+ tf.cast(images_gray_b, dtype=tf.float32))
+ images_g_diff = tf.multiply(images_g_diff1, images_g_diff2)
+ images_b_diff1 = tf.squared_difference(
+ tf.cast(images_b, dtype=tf.float32),
+ tf.cast(images_gray_b, dtype=tf.float32))
+ images_b_diff2 = tf.squared_difference(
+ tf.cast(images_gray_b, dtype=tf.float32),
+ tf.cast(images_gray_r, dtype=tf.float32))
+ images_b_diff = tf.multiply(images_b_diff1, images_b_diff2)
+ image_zero1 = tf.constant(0, dtype=tf.float32, shape=[1, 4, 4, 1])
+ with self.test_session() as sess:
+ (images_r_diff_, images_g_diff_, images_b_diff_, image_zero1_) = sess.run(
+ [images_r_diff, images_g_diff, images_b_diff, image_zero1])
+ self.assertAllClose(images_r_diff_, image_zero1_)
+ self.assertAllClose(images_g_diff_, image_zero1_)
+ self.assertAllClose(images_b_diff_, image_zero1_)
+
+ def testRandomRGBtoGrayWithCache(self):
+ preprocess_options = [(
+ preprocessor.random_rgb_to_gray, {'probability': 0.5})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustBrightness(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_brightness, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_bright = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_bright_shape = tf.shape(images_bright)
+ with self.test_session() as sess:
+ (image_original_shape_, image_bright_shape_) = sess.run(
+ [image_original_shape, image_bright_shape])
+ self.assertAllEqual(image_original_shape_, image_bright_shape_)
+
+ def testRandomAdjustBrightnessWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_brightness, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustContrast(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_contrast, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_contrast = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_contrast_shape = tf.shape(images_contrast)
+ with self.test_session() as sess:
+ (image_original_shape_, image_contrast_shape_) = sess.run(
+ [image_original_shape, image_contrast_shape])
+ self.assertAllEqual(image_original_shape_, image_contrast_shape_)
+
+ def testRandomAdjustContrastWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_contrast, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustHue(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_hue, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_hue = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_hue_shape = tf.shape(images_hue)
+ with self.test_session() as sess:
+ (image_original_shape_, image_hue_shape_) = sess.run(
+ [image_original_shape, image_hue_shape])
+ self.assertAllEqual(image_original_shape_, image_hue_shape_)
+
+ def testRandomAdjustHueWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_hue, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomDistortColor(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_distort_color, {}))
+ images_original = self.createTestImages()
+ images_original_shape = tf.shape(images_original)
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_distorted_color = tensor_dict[fields.InputDataFields.image]
+ images_distorted_color_shape = tf.shape(images_distorted_color)
+ with self.test_session() as sess:
+ (images_original_shape_, images_distorted_color_shape_) = sess.run(
+ [images_original_shape, images_distorted_color_shape])
+ self.assertAllEqual(images_original_shape_, images_distorted_color_shape_)
+
+ def testRandomDistortColorWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_distort_color, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomJitterBoxes(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.random_jitter_boxes, {}))
+ boxes = self.createTestBoxes()
+ boxes_shape = tf.shape(boxes)
+ tensor_dict = {fields.InputDataFields.groundtruth_boxes: boxes}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ distorted_boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ distorted_boxes_shape = tf.shape(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_shape_, distorted_boxes_shape_) = sess.run(
+ [boxes_shape, distorted_boxes_shape])
+ self.assertAllEqual(boxes_shape_, distorted_boxes_shape_)
+
+ def testRandomCropImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ self.assertEqual(3, distorted_images.get_shape()[3])
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithCache(self):
+ preprocess_options = [(preprocessor.random_rgb_to_gray,
+ {'probability': 0.5}),
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,
+ }),
+ (preprocessor.random_crop_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomCropImageGrayscale(self):
+ preprocessing_options = [(preprocessor.rgb_to_gray, {}),
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,
+ }),
+ (preprocessor.random_crop_image, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ self.assertEqual(1, distorted_images.get_shape()[3])
+
+ with self.test_session() as sess:
+ session_results = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = session_results
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithBoxOutOfImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxesOutOfImage()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_image, {
+ 'random_coef': 1.0
+ })]
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ boxes_shape = tf.shape(boxes)
+ distorted_boxes_shape = tf.shape(distorted_boxes)
+ images_shape = tf.shape(images)
+ distorted_images_shape = tf.shape(distorted_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, distorted_boxes_shape_, images_shape_,
+ distorted_images_shape_, images_, distorted_images_,
+ boxes_, distorted_boxes_, labels_, distorted_labels_,
+ weights_, distorted_weights_) = sess.run(
+ [boxes_shape, distorted_boxes_shape, images_shape,
+ distorted_images_shape, images, distorted_images,
+ boxes, distorted_boxes, labels, distorted_labels,
+ weights, distorted_weights])
+ self.assertAllEqual(boxes_shape_, distorted_boxes_shape_)
+ self.assertAllEqual(images_shape_, distorted_images_shape_)
+ self.assertAllClose(images_, distorted_images_)
+ self.assertAllClose(boxes_, distorted_boxes_)
+ self.assertAllEqual(labels_, distorted_labels_)
+ self.assertAllEqual(weights_, distorted_weights_)
+
+ def testRandomCropWithMockSampleDistortedBoundingBox(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createColorfulTestImage()
+ boxes = tf.constant([[0.1, 0.1, 0.8, 0.3],
+ [0.2, 0.4, 0.75, 0.75],
+ [0.3, 0.1, 0.4, 0.7]], dtype=tf.float32)
+ labels = tf.constant([1, 7, 11], dtype=tf.int32)
+ weights = tf.constant([1.0, 0.5, 0.6], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box') as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (tf.constant(
+ [6, 143, 0], dtype=tf.int32), tf.constant(
+ [190, 237, -1], dtype=tf.int32), tf.constant(
+ [[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ expected_boxes = tf.constant([[0.178947, 0.07173, 0.75789469, 0.66244733],
+ [0.28421, 0.0, 0.38947365, 0.57805908]],
+ dtype=tf.float32)
+ expected_labels = tf.constant([7, 11], dtype=tf.int32)
+ expected_weights = tf.constant([0.5, 0.6], dtype=tf.float32)
+
+ with self.test_session() as sess:
+ (distorted_boxes_, distorted_labels_, distorted_weights_,
+ expected_boxes_, expected_labels_, expected_weights_) = sess.run(
+ [distorted_boxes, distorted_labels, distorted_weights,
+ expected_boxes, expected_labels, expected_weights])
+ self.assertAllClose(distorted_boxes_, expected_boxes_)
+ self.assertAllEqual(distorted_labels_, expected_labels_)
+ self.assertAllEqual(distorted_weights_, expected_weights_)
+
+ def testRandomCropWithoutClipBoxes(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createColorfulTestImage()
+ boxes = tf.constant([[0.1, 0.1, 0.8, 0.3],
+ [0.2, 0.4, 0.75, 0.75],
+ [0.3, 0.1, 0.4, 0.7]], dtype=tf.float32)
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.8, 0.3]],
+ [[0.2, 0.4], [0.75, 0.75]],
+ [[0.3, 0.1], [0.4, 0.7]],
+ ], dtype=tf.float32)
+ labels = tf.constant([1, 7, 11], dtype=tf.int32)
+ weights = tf.constant([1.0, 0.5, 0.6], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {
+ 'clip_boxes': False,
+ })]
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box') as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (tf.constant(
+ [6, 143, 0], dtype=tf.int32), tf.constant(
+ [190, 237, -1], dtype=tf.int32), tf.constant(
+ [[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ expected_boxes = tf.constant(
+ [[0.178947, 0.07173, 0.75789469, 0.66244733],
+ [0.28421, -0.434599, 0.38947365, 0.57805908]],
+ dtype=tf.float32)
+ expected_keypoints = tf.constant(
+ [[[0.178947, 0.07173], [0.75789469, 0.66244733]],
+ [[0.28421, -0.434599], [0.38947365, 0.57805908]]],
+ dtype=tf.float32)
+ expected_labels = tf.constant([7, 11], dtype=tf.int32)
+ expected_weights = tf.constant([0.5, 0.6], dtype=tf.float32)
+
+ with self.test_session() as sess:
+ (distorted_boxes_, distorted_keypoints_, distorted_labels_,
+ distorted_weights_, expected_boxes_, expected_keypoints_,
+ expected_labels_, expected_weights_) = sess.run(
+ [distorted_boxes, distorted_keypoints, distorted_labels,
+ distorted_weights, expected_boxes, expected_keypoints,
+ expected_labels, expected_weights])
+ self.assertAllClose(distorted_boxes_, expected_boxes_)
+ self.assertAllClose(distorted_keypoints_, expected_keypoints_)
+ self.assertAllEqual(distorted_labels_, expected_labels_)
+ self.assertAllEqual(distorted_weights_, expected_weights_)
+
+ def testRandomCropImageWithMultiClassScores(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.multiclass_scores: multiclass_scores
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_multiclass_scores = distorted_tensor_dict[
+ fields.InputDataFields.multiclass_scores]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ multiclass_scores_rank = tf.rank(multiclass_scores)
+ distorted_multiclass_scores_rank = tf.rank(distorted_multiclass_scores)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_, multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_,
+ distorted_multiclass_scores_) = sess.run([
+ boxes_rank, distorted_boxes, distorted_boxes_rank, images_rank,
+ distorted_images_rank, multiclass_scores_rank,
+ distorted_multiclass_scores_rank, distorted_multiclass_scores
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+ self.assertAllEqual(multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_)
+ self.assertAllEqual(distorted_boxes_.shape[0],
+ distorted_multiclass_scores_.shape[0])
+
+ def testStrictRandomCropImageWithGroundtruthWeights(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_groundtruth_weights = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_groundtruth_weights = (
+ sess.run(
+ [new_image, new_boxes, new_labels, new_groundtruth_weights])
+ )
+
+ expected_boxes = np.array(
+ [[0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0]], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllEqual(new_groundtruth_weights, [1.0, 0.5])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+
+ def testStrictRandomCropImageWithMasks(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_weights, new_masks = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights, masks=masks))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_weights, new_masks = sess.run(
+ [new_image, new_boxes, new_labels, new_weights, new_masks])
+ expected_boxes = np.array(
+ [[0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0]], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllEqual(new_masks.shape, [2, 190, 237])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+
+ def testStrictRandomCropImageWithKeypoints(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_weights, new_keypoints = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights, keypoints=keypoints))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_weights, new_keypoints = sess.run(
+ [new_image, new_boxes, new_labels, new_weights, new_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]]
+ ], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ new_keypoints.flatten(), expected_keypoints.flatten())
+
+ def testRunRandomCropImageWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_masks])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_masks_.shape, [2, 190, 237])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+
+ def testRunRandomCropImageWithKeypointsInsideCrop(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypointsInsideCrop()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]],
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]]
+ ])
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ distorted_keypoints_.flatten(), expected_keypoints.flatten())
+
+ def testRunRandomCropImageWithKeypointsOutsideCrop(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypointsOutsideCrop()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ ])
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ distorted_keypoints_.flatten(), expected_keypoints.flatten())
+
+ def testRunRetainBoxesAboveThreshold(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map()
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_boxes = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ retained_labels = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ retained_weights = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_,
+ retained_weights_, expected_retained_boxes_,
+ expected_retained_labels_, expected_retained_weights_) = sess.run(
+ [retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterThresholding(),
+ self.expectedLabelsAfterThresholding(),
+ self.expectedLabelScoresAfterThresholding()])
+
+ self.assertAllClose(retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(retained_labels_, expected_retained_labels_)
+ self.assertAllClose(
+ retained_weights_, expected_retained_weights_)
+
+ def testRunRetainBoxesAboveThresholdWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_label_weights=True,
+ include_instance_masks=True)
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_masks = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+
+ with self.test_session() as sess:
+ (retained_masks_, expected_masks_) = sess.run(
+ [retained_masks,
+ self.expectedMasksAfterThresholding()])
+ self.assertAllClose(retained_masks_, expected_masks_)
+
+ def testRunRetainBoxesAboveThresholdWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_keypoints = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+
+ with self.test_session() as sess:
+ (retained_keypoints_, expected_keypoints_) = sess.run(
+ [retained_keypoints,
+ self.expectedKeypointsAfterThresholding()])
+ self.assertAllClose(retained_keypoints_, expected_keypoints_)
+
+ def testRandomCropToAspectRatioWithCache(self):
+ preprocess_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRunRandomCropToAspectRatioWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+
+ with mock.patch.object(preprocessor,
+ '_random_integer') as mock_random_integer:
+ mock_random_integer.return_value = tf.constant(0, dtype=tf.int32)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels, distorted_masks
+ ])
+
+ expected_boxes = np.array([0.0, 0.5, 0.75, 1.0], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 200, 200, 3])
+ self.assertAllEqual(distorted_labels_, [1])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllEqual(distorted_masks_.shape, [1, 200, 200])
+
+ def testRunRandomCropToAspectRatioWithKeypoints(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+
+ with mock.patch.object(preprocessor,
+ '_random_integer') as mock_random_integer:
+ mock_random_integer.return_value = tf.constant(0, dtype=tf.int32)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints
+ ])
+
+ expected_boxes = np.array([0.0, 0.5, 0.75, 1.0], dtype=np.float32)
+ expected_keypoints = np.array(
+ [[0.1, 0.2], [0.2, 0.4], [0.3, 0.6]], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 200, 200, 3])
+ self.assertAllEqual(distorted_labels_, [1])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllClose(distorted_keypoints_.flatten(),
+ expected_keypoints.flatten())
+
+ def testRandomPadToAspectRatioWithCache(self):
+ preprocess_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomPadToAspectRatioWithMinMaxPaddedSizeRatios(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map()
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio,
+ {'min_padded_size_ratio': (4.0, 4.0),
+ 'max_padded_size_ratio': (4.0, 4.0)})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ with self.test_session() as sess:
+ distorted_image_, distorted_boxes_, distorted_labels_ = sess.run([
+ distorted_image, distorted_boxes, distorted_labels])
+
+ expected_boxes = np.array(
+ [[0.0, 0.125, 0.1875, 0.5], [0.0625, 0.25, 0.1875, 0.5]],
+ dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 800, 800, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+
+ def testRunRandomPadToAspectRatioWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels, distorted_masks
+ ])
+
+ expected_boxes = np.array(
+ [[0.0, 0.25, 0.375, 1.0], [0.125, 0.5, 0.375, 1.0]], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 400, 400, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllEqual(distorted_masks_.shape, [2, 400, 400])
+
+ def testRunRandomPadToAspectRatioWithKeypoints(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints
+ ])
+
+ expected_boxes = np.array(
+ [[0.0, 0.25, 0.375, 1.0], [0.125, 0.5, 0.375, 1.0]], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[0.05, 0.1], [0.1, 0.2], [0.15, 0.3]],
+ [[0.2, 0.4], [0.25, 0.5], [0.3, 0.6]],
+ ], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 400, 400, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllClose(distorted_keypoints_.flatten(),
+ expected_keypoints.flatten())
+
+ def testRandomPadImageWithCache(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,}), (preprocessor.random_pad_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomPadImage(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_image, {})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_, boxes_, padded_boxes_) = sess.run(
+ [boxes_shape, padded_boxes_shape, images_shape,
+ padded_images_shape, boxes, padded_boxes])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+
+ def testRandomPadImageWithKeypoints(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ keypoints = self.createTestKeypoints()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_image, {})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ padded_keypoints = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ keypoints_shape = tf.shape(keypoints)
+ padded_keypoints_shape = tf.shape(padded_keypoints)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, keypoints_shape_,
+ padded_keypoints_shape_, images_shape_, padded_images_shape_, boxes_,
+ padded_boxes_, keypoints_, padded_keypoints_) = sess.run(
+ [boxes_shape, padded_boxes_shape, keypoints_shape,
+ padded_keypoints_shape, images_shape, padded_images_shape, boxes,
+ padded_boxes, keypoints, padded_keypoints])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertAllEqual(keypoints_shape_, padded_keypoints_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+ self.assertTrue(np.all((keypoints_[1, :, 0] - keypoints_[0, :, 0]) >= (
+ padded_keypoints_[1, :, 0] - padded_keypoints_[0, :, 0])))
+ self.assertTrue(np.all((keypoints_[1, :, 1] - keypoints_[0, :, 1]) >= (
+ padded_keypoints_[1, :, 1] - padded_keypoints_[0, :, 1])))
+
+ def testRandomAbsolutePadImage(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: tf.cast(images, dtype=tf.float32),
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+
+ height_padding = 10
+ width_padding = 20
+ preprocessing_options = [(preprocessor.random_absolute_pad_image, {
+ 'max_height_padding': height_padding,
+ 'max_width_padding': width_padding})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ original_shape = tf.shape(images)
+ final_shape = tf.shape(padded_tensor_dict[fields.InputDataFields.image])
+
+ with self.test_session() as sess:
+ _, height, width, _ = sess.run(original_shape)
+ for _ in range(100):
+ output_shape = sess.run(final_shape)
+
+ self.assertTrue(output_shape[1] >= height)
+ self.assertTrue(output_shape[1] < height + height_padding)
+ self.assertTrue(output_shape[2] >= width)
+ self.assertTrue(output_shape[2] < width + width_padding)
+
+ def testRandomCropPadImageWithCache(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,}), (preprocessor.random_crop_pad_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomCropPadImageWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_pad_image, {
+ 'random_coef': 1.0
+ })]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_, boxes_, padded_boxes_) = sess.run(
+ [boxes_shape, padded_boxes_shape, images_shape,
+ padded_images_shape, boxes, padded_boxes])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+
+ def testRandomCropToAspectRatio(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, [])
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {
+ 'aspect_ratio': 2.0
+ })]
+ cropped_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ cropped_images = cropped_tensor_dict[fields.InputDataFields.image]
+ cropped_boxes = cropped_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ cropped_boxes_shape = tf.shape(cropped_boxes)
+ images_shape = tf.shape(images)
+ cropped_images_shape = tf.shape(cropped_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, cropped_boxes_shape_, images_shape_,
+ cropped_images_shape_) = sess.run([
+ boxes_shape, cropped_boxes_shape, images_shape, cropped_images_shape
+ ])
+ self.assertAllEqual(boxes_shape_, cropped_boxes_shape_)
+ self.assertEqual(images_shape_[1], cropped_images_shape_[1] * 2)
+ self.assertEqual(images_shape_[2], cropped_images_shape_[2])
+
+ def testRandomPadToAspectRatio(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, [])
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {
+ 'aspect_ratio': 2.0
+ })]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_) = sess.run([
+ boxes_shape, padded_boxes_shape, images_shape, padded_images_shape
+ ])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertEqual(images_shape_[1], padded_images_shape_[1])
+ self.assertEqual(2 * images_shape_[2], padded_images_shape_[2])
+
+ def testRandomBlackPatchesWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_black_patches, {
+ 'size_to_image_ratio': 0.5
+ }))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomBlackPatches(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_black_patches, {
+ 'size_to_image_ratio': 0.5
+ }))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ blacked_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ blacked_images = blacked_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ blacked_images_shape = tf.shape(blacked_images)
+
+ with self.test_session() as sess:
+ (images_shape_, blacked_images_shape_) = sess.run(
+ [images_shape, blacked_images_shape])
+ self.assertAllEqual(images_shape_, blacked_images_shape_)
+
+ def testRandomJpegQuality(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ encoded_images_shape = tf.shape(encoded_images)
+
+ with self.test_session() as sess:
+ images_shape_out, encoded_images_shape_out = sess.run(
+ [images_shape, encoded_images_shape])
+ self.assertAllEqual(images_shape_out, encoded_images_shape_out)
+
+ def testRandomJpegQualityKeepsStaticChannelShape(self):
+ # Set at least three weeks past the forward compatibility horizon for
+ # tf 1.14 of 2019/11/01.
+ # https://github.com/tensorflow/tensorflow/blob/v1.14.0/tensorflow/python/compat/compat.py#L30
+ if not tf.compat.forward_compatible(year=2019, month=12, day=1):
+ self.skipTest('Skipping test for future functionality.')
+
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_static_channels = images.shape[-1]
+ encoded_images_static_channels = encoded_images.shape[-1]
+ self.assertEqual(images_static_channels, encoded_images_static_channels)
+
+ def testRandomJpegQualityWithCache(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ self._testPreprocessorCache(preprocessing_options)
+
+ def testRandomJpegQualityWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'random_coef': 1.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ encoded_images_shape = tf.shape(encoded_images)
+
+ with self.test_session() as sess:
+ (images_out, encoded_images_out, images_shape_out,
+ encoded_images_shape_out) = sess.run(
+ [images, encoded_images, images_shape, encoded_images_shape])
+ self.assertAllEqual(images_shape_out, encoded_images_shape_out)
+ self.assertAllEqual(images_out, encoded_images_out)
+
+ def testRandomDownscaleToTargetPixels(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 101
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ downscaled_shape = tf.shape(downscaled_images)
+ expected_shape = [1, 5, 20, 3]
+ with self.test_session() as sess:
+ downscaled_shape_out = sess.run(downscaled_shape)
+ self.assertAllEqual(downscaled_shape_out, expected_shape)
+
+ def testRandomDownscaleToTargetPixelsWithMasks(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 101
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ masks = tf.random_uniform([10, 25, 100])
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+ processed_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ downscaled_masks = processed_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ downscaled_images_shape = tf.shape(downscaled_images)
+ downscaled_masks_shape = tf.shape(downscaled_masks)
+ expected_images_shape = [1, 5, 20, 3]
+ expected_masks_shape = [10, 5, 20]
+ with self.test_session() as sess:
+ downscaled_images_shape_out, downscaled_masks_shape_out = sess.run(
+ [downscaled_images_shape, downscaled_masks_shape])
+ self.assertAllEqual(downscaled_images_shape_out, expected_images_shape)
+ self.assertAllEqual(downscaled_masks_shape_out, expected_masks_shape)
+
+ @parameterized.parameters(
+ {'test_masks': False},
+ {'test_masks': True}
+ )
+ def testRandomDownscaleToTargetPixelsWithCache(self, test_masks):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 999
+ })]
+ self._testPreprocessorCache(preprocessing_options, test_masks=test_masks)
+
+ def testRandomDownscaleToTargetPixelsWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'random_coef': 1.0,
+ 'min_target_pixels': 10,
+ 'max_target_pixels': 20,
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ downscaled_images_shape = tf.shape(downscaled_images)
+
+ with self.test_session() as sess:
+ (images_out, downscaled_images_out, images_shape_out,
+ downscaled_images_shape_out) = sess.run(
+ [images, downscaled_images, images_shape, downscaled_images_shape])
+ self.assertAllEqual(images_shape_out, downscaled_images_shape_out)
+ self.assertAllEqual(images_out, downscaled_images_out)
+
+ def testRandomDownscaleToTargetPixelsIgnoresSmallImages(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 1000,
+ 'max_target_pixels': 1001
+ })]
+ images = tf.random_uniform([1, 10, 10, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ downscaled_images_shape = tf.shape(downscaled_images)
+ with self.test_session() as sess:
+ (images_out, downscaled_images_out, images_shape_out,
+ downscaled_images_shape_out) = sess.run(
+ [images, downscaled_images, images_shape, downscaled_images_shape])
+ self.assertAllEqual(images_shape_out, downscaled_images_shape_out)
+ self.assertAllEqual(images_out, downscaled_images_out)
+
+ def testRandomPatchGaussianShape(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 1,
+ 'max_patch_size': 200,
+ 'min_gaussian_stddev': 0.0,
+ 'max_gaussian_stddev': 2.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ patched_images_shape = tf.shape(patched_images)
+ self.assertAllEqual(images_shape, patched_images_shape)
+
+ def testRandomPatchGaussianClippedToLowerBound(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 20,
+ 'max_patch_size': 40,
+ 'min_gaussian_stddev': 50,
+ 'max_gaussian_stddev': 100
+ })]
+ images = tf.zeros([1, 5, 4, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ self.assertAllGreaterEqual(patched_images, 0.0)
+
+ def testRandomPatchGaussianClippedToUpperBound(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 20,
+ 'max_patch_size': 40,
+ 'min_gaussian_stddev': 50,
+ 'max_gaussian_stddev': 100
+ })]
+ images = tf.constant(255.0, shape=[1, 5, 4, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ self.assertAllLessEqual(patched_images, 255.0)
+
+ def testRandomPatchGaussianWithCache(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 1,
+ 'max_patch_size': 200,
+ 'min_gaussian_stddev': 0.0,
+ 'max_gaussian_stddev': 2.0
+ })]
+ self._testPreprocessorCache(preprocessing_options)
+
+ def testRandomPatchGaussianWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'random_coef': 1.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ patched_images_shape = tf.shape(patched_images)
+
+ self.assertAllEqual(images_shape, patched_images_shape)
+ self.assertAllEqual(images, patched_images)
+
+ def testAutoAugmentImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.autoaugment_image, {
+ 'policy_name': 'v1'
+ }))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ autoaugment_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options)
+ augmented_images = autoaugment_tensor_dict[fields.InputDataFields.image]
+ augmented_boxes = autoaugment_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ images_shape = tf.shape(images)
+ boxes_shape = tf.shape(boxes)
+ augmented_images_shape = tf.shape(augmented_images)
+ augmented_boxes_shape = tf.shape(augmented_boxes)
+
+ with self.test_session() as sess:
+ (images_shape_, boxes_shape_,
+ augmented_images_shape_, augmented_boxes_shape_) = sess.run(
+ [images_shape, boxes_shape,
+ augmented_images_shape, augmented_boxes_shape])
+ self.assertAllEqual(images_shape_, augmented_images_shape_)
+ self.assertAllEqual(boxes_shape_, augmented_boxes_shape_)
+
+ def testRandomResizeMethodWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_resize_method, {
+ 'target_size': (75, 150)
+ }))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomResizeMethod(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_resize_method, {
+ 'target_size': (75, 150)
+ }))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ resized_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ resized_images = resized_tensor_dict[fields.InputDataFields.image]
+ resized_images_shape = tf.shape(resized_images)
+ expected_images_shape = tf.constant([1, 75, 150, 3], dtype=tf.int32)
+
+ with self.test_session() as sess:
+ (expected_images_shape_, resized_images_shape_) = sess.run(
+ [expected_images_shape, resized_images_shape])
+ self.assertAllEqual(expected_images_shape_,
+ resized_images_shape_)
+
+ def testResizeImageWithMasks(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ height = 50
+ width = 100
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 50, 100], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeImageWithMasksTensorInputHeightAndWidth(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ height = tf.constant(50, dtype=tf.int32)
+ width = tf.constant(100, dtype=tf.int32)
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 50, 100], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeImageWithNoInstanceMask(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ height = 50
+ width = 100
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 50, 100], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangePreservesStaticSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[75, 50, 3], [50, 100, 3], [30, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.random_uniform(in_shape)
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ self.assertAllEqual(out_image.get_shape().as_list(), expected_shape)
+
+ def testResizeToRangeWithDynamicSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[75, 50, 3], [50, 100, 3], [30, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ with self.test_session() as sess:
+ out_image_shape = sess.run(out_image_shape,
+ feed_dict={in_image:
+ np.random.randn(*in_shape)})
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToRangeWithPadToMaxDimensionReturnsCorrectShapes(self):
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[100, 100, 3], [100, 100, 3], [100, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True)
+ self.assertAllEqual(out_image.shape.as_list(), expected_shape)
+ out_image_shape = tf.shape(out_image)
+ with self.test_session() as sess:
+ out_image_shape = sess.run(
+ out_image_shape, feed_dict={in_image: np.random.randn(*in_shape)})
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToRangeWithPadToMaxDimensionReturnsCorrectTensor(self):
+ in_image_np = np.array([[[0, 1, 2]]], np.float32)
+ ex_image_np = np.array(
+ [[[0, 1, 2], [123.68, 116.779, 103.939]],
+ [[123.68, 116.779, 103.939], [123.68, 116.779, 103.939]]], np.float32)
+ min_dim = 1
+ max_dim = 2
+
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True,
+ per_channel_pad_value=(123.68, 116.779, 103.939))
+
+ with self.test_session() as sess:
+ out_image_np = sess.run(out_image, feed_dict={in_image: in_image_np})
+ self.assertAllClose(ex_image_np, out_image_np)
+
+ def testResizeToRangeWithMasksPreservesStaticSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 75, 50], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ self.assertAllEqual(out_masks.get_shape().as_list(), expected_mask_shape)
+ self.assertAllEqual(out_image.get_shape().as_list(), expected_image_shape)
+
+ def testResizeToRangeWithMasksAndPadToMaxDimension(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[100, 100, 3], [100, 100, 3]]
+ expected_masks_shape_list = [[15, 100, 100], [10, 100, 100]]
+
+ for (in_image_shape,
+ expected_image_shape, in_masks_shape, expected_mask_shape) in zip(
+ in_image_shape_list, expected_image_shape_list,
+ in_masks_shape_list, expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image,
+ in_masks,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangeWithMasksAndDynamicSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 75, 50], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangeWithInstanceMasksTensorOfSizeZero(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 75, 50], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRange4DImageTensor(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_range(image, 500, 600)
+
+ def testResizeToRangeSameMinMax(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[312, 312, 3], [299, 299, 3]]
+ min_dim = 320
+ max_dim = 320
+ expected_shape_list = [[320, 320, 3], [320, 320, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.random_uniform(in_shape)
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+
+ with self.test_session() as sess:
+ out_image_shape = sess.run(out_image_shape)
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToMaxDimensionTensorShapes(self):
+ """Tests both cases where image should and shouldn't be resized."""
+ in_image_shape_list = [[100, 50, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 100, 50], [10, 15, 30]]
+ max_dim = 50
+ expected_image_shape_list = [[50, 25, 3], [15, 30, 3]]
+ expected_masks_shape_list = [[15, 50, 25], [10, 15, 30]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_max_dimension(
+ in_image, in_masks, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMaxDimensionWithInstanceMasksTensorOfSizeZero(self):
+ """Tests both cases where image should and shouldn't be resized."""
+ in_image_shape_list = [[100, 50, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 100, 50], [0, 15, 30]]
+ max_dim = 50
+ expected_image_shape_list = [[50, 25, 3], [15, 30, 3]]
+ expected_masks_shape_list = [[0, 50, 25], [0, 15, 30]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_max_dimension(
+ in_image, in_masks, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMaxDimensionRaisesErrorOn4DImage(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_max_dimension(image, 500)
+
+ def testResizeToMinDimensionTensorShapes(self):
+ in_image_shape_list = [[60, 55, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 55], [10, 15, 30]]
+ min_dim = 50
+ expected_image_shape_list = [[60, 55, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 60, 55], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_min_dimension(
+ in_image, in_masks, min_dimension=min_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMinDimensionWithInstanceMasksTensorOfSizeZero(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ min_dim = 50
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 75, 50], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_min_dimension(
+ in_image, in_masks, min_dimension=min_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMinDimensionRaisesErrorOn4DImage(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_min_dimension(image, 500)
+
+ def testScaleBoxesToPixelCoordinates(self):
+ """Tests box scaling, checking scaled values."""
+ in_shape = [60, 40, 3]
+ in_boxes = [[0.1, 0.2, 0.4, 0.6],
+ [0.5, 0.3, 0.9, 0.7]]
+
+ expected_boxes = [[6., 8., 24., 24.],
+ [30., 12., 54., 28.]]
+
+ in_image = tf.random_uniform(in_shape)
+ in_boxes = tf.constant(in_boxes)
+ _, out_boxes = preprocessor.scale_boxes_to_pixel_coordinates(
+ in_image, boxes=in_boxes)
+ with self.test_session() as sess:
+ out_boxes = sess.run(out_boxes)
+ self.assertAllClose(out_boxes, expected_boxes)
+
+ def testScaleBoxesToPixelCoordinatesWithKeypoints(self):
+ """Tests box and keypoint scaling, checking scaled values."""
+ in_shape = [60, 40, 3]
+ in_boxes = self.createTestBoxes()
+ in_keypoints = self.createTestKeypoints()
+
+ expected_boxes = [[0., 10., 45., 40.],
+ [15., 20., 45., 40.]]
+ expected_keypoints = [
+ [[6., 4.], [12., 8.], [18., 12.]],
+ [[24., 16.], [30., 20.], [36., 24.]],
+ ]
+
+ in_image = tf.random_uniform(in_shape)
+ _, out_boxes, out_keypoints = preprocessor.scale_boxes_to_pixel_coordinates(
+ in_image, boxes=in_boxes, keypoints=in_keypoints)
+ with self.test_session() as sess:
+ out_boxes_, out_keypoints_ = sess.run([out_boxes, out_keypoints])
+ self.assertAllClose(out_boxes_, expected_boxes)
+ self.assertAllClose(out_keypoints_, expected_keypoints)
+
+ def testSubtractChannelMean(self):
+ """Tests whether channel means have been subtracted."""
+ with self.test_session():
+ image = tf.zeros((240, 320, 3))
+ means = [1, 2, 3]
+ actual = preprocessor.subtract_channel_mean(image, means=means)
+ actual = actual.eval()
+
+ self.assertTrue((actual[:, :, 0] == -1).all())
+ self.assertTrue((actual[:, :, 1] == -2).all())
+ self.assertTrue((actual[:, :, 2] == -3).all())
+
+ def testOneHotEncoding(self):
+ """Tests one hot encoding of multiclass labels."""
+ with self.test_session():
+ labels = tf.constant([1, 4, 2], dtype=tf.int32)
+ one_hot = preprocessor.one_hot_encoding(labels, num_classes=5)
+ one_hot = one_hot.eval()
+
+ self.assertAllEqual([0, 1, 1, 0, 1], one_hot)
+
+ def testRandomSelfConcatImage(self):
+ tf.set_random_seed(24601)
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ confidences = weights
+ scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: tf.cast(images, dtype=tf.float32),
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_confidences: confidences,
+ fields.InputDataFields.multiclass_scores: scores,
+ }
+
+ preprocessing_options = [(preprocessor.random_self_concat_image, {
+ 'concat_vertical_probability': 0.5,
+ 'concat_horizontal_probability': 0.5,
+ 'seed': 24601,
+ })]
+ func_arg_map = preprocessor.get_default_func_arg_map(
+ True, True, True)
+ output_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=func_arg_map)
+
+ final_shape = tf.shape(output_tensor_dict[fields.InputDataFields.image])[
+ 1:3]
+
+ with self.test_session() as sess:
+ outputs = []
+
+ augment_height_only = False
+ augment_width_only = False
+
+ for _ in range(50):
+ original_boxes = sess.run(boxes)
+ shape, new_boxes, new_labels, new_confidences, new_scores = sess.run(
+ [final_shape,
+ output_tensor_dict[fields.InputDataFields.groundtruth_boxes],
+ output_tensor_dict[fields.InputDataFields.groundtruth_classes],
+ output_tensor_dict[fields.InputDataFields.groundtruth_confidences],
+ output_tensor_dict[fields.InputDataFields.multiclass_scores],
+ ])
+ shape = np.array(shape)
+ outputs.append(shape)
+
+ if np.array_equal(shape, [8, 4]):
+ augment_height_only = True
+ self.assertEqual(
+ new_boxes.shape[0], 2 * boxes.shape[0])
+
+ self.assertAllClose(new_boxes[:2, :] * [2.0, 1.0, 2.0, 1.0],
+ original_boxes)
+ self.assertAllClose(
+ (new_boxes[2:, :] - [0.5, 0.0, 0.5, 0.0]) * [
+ 2.0, 1.0, 2.0, 1.0],
+ original_boxes)
+ elif np.array_equal(shape, [4, 8]):
+ augment_width_only = True
+ self.assertEqual(
+ new_boxes.shape[0], 2 * boxes.shape[0])
+
+ self.assertAllClose(new_boxes[:2, :] * [1.0, 2.0, 1.0, 2.0],
+ original_boxes)
+ self.assertAllClose(
+ (new_boxes[2:, :] - [0.0, 0.5, 0.0, 0.5]) * [
+ 1.0, 2.0, 1.0, 2.0],
+ original_boxes)
+
+ augmentation_factor = new_boxes.shape[0] / boxes.shape[0].value
+ self.assertEqual(new_labels.shape[0],
+ labels.shape[0].value * augmentation_factor)
+ self.assertEqual(new_confidences.shape[0],
+ confidences.shape[0].value * augmentation_factor)
+ self.assertEqual(new_scores.shape[0],
+ scores.shape[0].value * augmentation_factor)
+
+ max_height = max(x[0] for x in outputs)
+ max_width = max(x[1] for x in outputs)
+
+ self.assertEqual(max_height, 8)
+ self.assertEqual(max_width, 8)
+ self.assertEqual(augment_height_only, True)
+ self.assertEqual(augment_width_only, True)
+
+ def testSSDRandomCropWithCache(self):
+ preprocess_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testSSDRandomCrop(self):
+ preprocessing_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropWithMultiClassScores(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }), (preprocessor.ssd_random_crop, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.multiclass_scores: multiclass_scores,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_multiclass_scores=True)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_multiclass_scores = distorted_tensor_dict[
+ fields.InputDataFields.multiclass_scores]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ multiclass_scores_rank = tf.rank(multiclass_scores)
+ distorted_multiclass_scores_rank = tf.rank(distorted_multiclass_scores)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_, multiclass_scores_rank_,
+ distorted_multiclass_scores_,
+ distorted_multiclass_scores_rank_) = sess.run([
+ boxes_rank, distorted_boxes, distorted_boxes_rank, images_rank,
+ distorted_images_rank, multiclass_scores_rank,
+ distorted_multiclass_scores, distorted_multiclass_scores_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+ self.assertAllEqual(multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_)
+ self.assertAllEqual(distorted_boxes_.shape[0],
+ distorted_multiclass_scores_.shape[0])
+
+ def testSSDRandomCropPad(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ preprocessing_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop_pad, {})]
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropFixedAspectRatioWithCache(self):
+ preprocess_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop_fixed_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def _testSSDRandomCropFixedAspectRatio(self,
+ include_multiclass_scores,
+ include_instance_masks,
+ include_keypoints):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }), (preprocessor.ssd_random_crop_fixed_aspect_ratio, {})]
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ if include_multiclass_scores:
+ multiclass_scores = self.createTestMultiClassScores()
+ tensor_dict[fields.InputDataFields.multiclass_scores] = (
+ multiclass_scores)
+ if include_instance_masks:
+ masks = self.createTestMasks()
+ tensor_dict[fields.InputDataFields.groundtruth_instance_masks] = masks
+ if include_keypoints:
+ keypoints = self.createTestKeypoints()
+ tensor_dict[fields.InputDataFields.groundtruth_keypoints] = keypoints
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_multiclass_scores=include_multiclass_scores,
+ include_instance_masks=include_instance_masks,
+ include_keypoints=include_keypoints)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropFixedAspectRatio(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=False,
+ include_keypoints=False)
+
+ def testSSDRandomCropFixedAspectRatioWithMultiClassScores(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=True,
+ include_instance_masks=False,
+ include_keypoints=False)
+
+ def testSSDRandomCropFixedAspectRatioWithMasksAndKeypoints(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=True,
+ include_keypoints=True)
+
+ def testSSDRandomCropFixedAspectRatioWithLabelScoresMasksAndKeypoints(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=True,
+ include_keypoints=True)
+
+ def testConvertClassLogitsToSoftmax(self):
+ multiclass_scores = tf.constant(
+ [[1.0, 0.0], [0.5, 0.5], [1000, 1]], dtype=tf.float32)
+ temperature = 2.0
+
+ converted_multiclass_scores = (
+ preprocessor.convert_class_logits_to_softmax(
+ multiclass_scores=multiclass_scores, temperature=temperature))
+
+ expected_converted_multiclass_scores = [[[0.62245935, 0.37754068],
+ [0.5, 0.5], [1, 0]]]
+
+ with self.test_session() as sess:
+ (converted_multiclass_scores_) = sess.run([converted_multiclass_scores])
+
+ self.assertAllClose(converted_multiclass_scores_,
+ expected_converted_multiclass_scores)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator.py b/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator.py
new file mode 100644
index 00000000..7b6e1485
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator.py
@@ -0,0 +1,159 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Region Similarity Calculators for BoxLists.
+
+Region Similarity Calculators compare a pairwise measure of similarity
+between the boxes in two BoxLists.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+import tensorflow as tf
+
+from object_detection.core import box_list_ops
+from object_detection.core import standard_fields as fields
+
+
+class RegionSimilarityCalculator(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for region similarity calculator."""
+
+ def compare(self, boxlist1, boxlist2, scope=None):
+ """Computes matrix of pairwise similarity between BoxLists.
+
+ This op (to be overridden) computes a measure of pairwise similarity between
+ the boxes in the given BoxLists. Higher values indicate more similarity.
+
+ Note that this method simply measures similarity and does not explicitly
+ perform a matching.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+ scope: Op scope name. Defaults to 'Compare' if None.
+
+ Returns:
+ a (float32) tensor of shape [N, M] with pairwise similarity score.
+ """
+ with tf.name_scope(scope, 'Compare', [boxlist1, boxlist2]) as scope:
+ return self._compare(boxlist1, boxlist2)
+
+ @abstractmethod
+ def _compare(self, boxlist1, boxlist2):
+ pass
+
+
+class IouSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on Intersection over Union (IOU) metric.
+
+ This class computes pairwise similarity between two BoxLists based on IOU.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOU similarity between the two BoxLists.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing pairwise iou scores.
+ """
+ return box_list_ops.iou(boxlist1, boxlist2)
+
+
+class NegSqDistSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on the squared distance metric.
+
+ This class computes pairwise similarity between two BoxLists based on the
+ negative squared distance metric.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute matrix of (negated) sq distances.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing negated pairwise squared distance.
+ """
+ return -1 * box_list_ops.sq_dist(boxlist1, boxlist2)
+
+
+class IoaSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on Intersection over Area (IOA) metric.
+
+ This class computes pairwise similarity between two BoxLists based on their
+ pairwise intersections divided by the areas of second BoxLists.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOA similarity between the two BoxLists.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing pairwise IOA scores.
+ """
+ return box_list_ops.ioa(boxlist1, boxlist2)
+
+
+class ThresholdedIouSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on thresholded IOU and score.
+
+ This class computes pairwise similarity between two BoxLists based on IOU and
+ a 'score' present in boxlist1. If IOU > threshold, then the entry in the
+ output pairwise tensor will contain `score`, otherwise 0.
+ """
+
+ def __init__(self, iou_threshold=0):
+ """Initialize the ThresholdedIouSimilarity.
+
+ Args:
+ iou_threshold: For a given pair of boxes, if the IOU is > iou_threshold,
+ then the comparison result will be the foreground probability of
+ the first box, otherwise it will be zero.
+ """
+ super(ThresholdedIouSimilarity, self).__init__()
+ self._iou_threshold = iou_threshold
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOU similarity between the two BoxLists and score.
+
+ Args:
+ boxlist1: BoxList holding N boxes. Must have a score field.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing scores threholded by pairwise
+ iou scores.
+ """
+ ious = box_list_ops.iou(boxlist1, boxlist2)
+ scores = boxlist1.get_field(fields.BoxListFields.scores)
+ scores = tf.expand_dims(scores, axis=1)
+ row_replicated_scores = tf.tile(scores, [1, tf.shape(ious)[-1]])
+ thresholded_ious = tf.where(ious > self._iou_threshold,
+ row_replicated_scores, tf.zeros_like(ious))
+
+ return thresholded_ious
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator_test.py b/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator_test.py
new file mode 100644
index 00000000..1d0c26bb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/region_similarity_calculator_test.py
@@ -0,0 +1,95 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for region_similarity_calculator."""
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import region_similarity_calculator
+from object_detection.core import standard_fields as fields
+
+
+class RegionSimilarityCalculatorTest(tf.test.TestCase):
+
+ def test_get_correct_pairwise_similarity_based_on_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0 / 16.0, 0, 6.0 / 400.0], [1.0 / 16.0, 0.0, 5.0 / 400.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou_similarity_calculator = region_similarity_calculator.IouSimilarity()
+ iou_similarity = iou_similarity_calculator.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou_similarity)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_get_correct_pairwise_similarity_based_on_squared_distances(self):
+ corners1 = tf.constant([[0.0, 0.0, 0.0, 0.0],
+ [1.0, 1.0, 0.0, 2.0]])
+ corners2 = tf.constant([[3.0, 4.0, 1.0, 0.0],
+ [-4.0, 0.0, 0.0, 3.0],
+ [0.0, 0.0, 0.0, 0.0]])
+ exp_output = [[-26, -25, 0], [-18, -27, -6]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ dist_similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ dist_similarity = dist_similarity_calc.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ dist_output = sess.run(dist_similarity)
+ self.assertAllClose(dist_output, exp_output)
+
+ def test_get_correct_pairwise_similarity_based_on_ioa(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output_1 = [[2.0 / 12.0, 0, 6.0 / 400.0],
+ [1.0 / 12.0, 0.0, 5.0 / 400.0]]
+ exp_output_2 = [[2.0 / 6.0, 1.0 / 5.0],
+ [0, 0],
+ [6.0 / 6.0, 5.0 / 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ ioa_similarity_calculator = region_similarity_calculator.IoaSimilarity()
+ ioa_similarity_1 = ioa_similarity_calculator.compare(boxes1, boxes2)
+ ioa_similarity_2 = ioa_similarity_calculator.compare(boxes2, boxes1)
+ with self.test_session() as sess:
+ iou_output_1, iou_output_2 = sess.run(
+ [ioa_similarity_1, ioa_similarity_2])
+ self.assertAllClose(iou_output_1, exp_output_1)
+ self.assertAllClose(iou_output_2, exp_output_2)
+
+ def test_get_correct_pairwise_similarity_based_on_thresholded_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ scores = tf.constant([.3, .6])
+ iou_threshold = .013
+
+ exp_output = tf.constant([[0.3, 0., 0.3], [0.6, 0., 0.]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes1.add_field(fields.BoxListFields.scores, scores)
+ boxes2 = box_list.BoxList(corners2)
+ iou_similarity_calculator = (
+ region_similarity_calculator.ThresholdedIouSimilarity(
+ iou_threshold=iou_threshold))
+ iou_similarity = iou_similarity_calculator.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou_similarity)
+ self.assertAllClose(iou_output, exp_output)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/standard_fields.py b/Computer Vision/Plant_Disease_Detection_System/core/standard_fields.py
new file mode 100644
index 00000000..628902eb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/standard_fields.py
@@ -0,0 +1,263 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Contains classes specifying naming conventions used for object detection.
+
+
+Specifies:
+ InputDataFields: standard fields used by reader/preprocessor/batcher.
+ DetectionResultFields: standard fields returned by object detector.
+ BoxListFields: standard field used by BoxList
+ TfExampleFields: standard fields for tf-example data format (go/tf-example).
+"""
+
+
+class InputDataFields(object):
+ """Names for the input tensors.
+
+ Holds the standard data field names to use for identifying input tensors. This
+ should be used by the decoder to identify keys for the returned tensor_dict
+ containing input tensors. And it should be used by the model to identify the
+ tensors it needs.
+
+ Attributes:
+ image: image.
+ image_additional_channels: additional channels.
+ original_image: image in the original input size.
+ original_image_spatial_shape: image in the original input size.
+ key: unique key corresponding to image.
+ source_id: source of the original image.
+ filename: original filename of the dataset (without common path).
+ groundtruth_image_classes: image-level class labels.
+ groundtruth_image_confidences: image-level class confidences.
+ groundtruth_boxes: coordinates of the ground truth boxes in the image.
+ groundtruth_classes: box-level class labels.
+ groundtruth_confidences: box-level class confidences. The shape should be
+ the same as the shape of groundtruth_classes.
+ groundtruth_label_types: box-level label types (e.g. explicit negative).
+ groundtruth_is_crowd: [DEPRECATED, use groundtruth_group_of instead]
+ is the groundtruth a single object or a crowd.
+ groundtruth_area: area of a groundtruth segment.
+ groundtruth_difficult: is a `difficult` object
+ groundtruth_group_of: is a `group_of` objects, e.g. multiple objects of the
+ same class, forming a connected group, where instances are heavily
+ occluding each other.
+ proposal_boxes: coordinates of object proposal boxes.
+ proposal_objectness: objectness score of each proposal.
+ groundtruth_instance_masks: ground truth instance masks.
+ groundtruth_instance_boundaries: ground truth instance boundaries.
+ groundtruth_instance_classes: instance mask-level class labels.
+ groundtruth_keypoints: ground truth keypoints.
+ groundtruth_keypoint_visibilities: ground truth keypoint visibilities.
+ groundtruth_label_weights: groundtruth label weights.
+ groundtruth_weights: groundtruth weight factor for bounding boxes.
+ num_groundtruth_boxes: number of groundtruth boxes.
+ is_annotated: whether an image has been labeled or not.
+ true_image_shapes: true shapes of images in the resized images, as resized
+ images can be padded with zeros.
+ multiclass_scores: the label score per class for each box.
+ """
+ image = 'image'
+ image_additional_channels = 'image_additional_channels'
+ original_image = 'original_image'
+ original_image_spatial_shape = 'original_image_spatial_shape'
+ key = 'key'
+ source_id = 'source_id'
+ filename = 'filename'
+ groundtruth_image_classes = 'groundtruth_image_classes'
+ groundtruth_image_confidences = 'groundtruth_image_confidences'
+ groundtruth_boxes = 'groundtruth_boxes'
+ groundtruth_classes = 'groundtruth_classes'
+ groundtruth_confidences = 'groundtruth_confidences'
+ groundtruth_label_types = 'groundtruth_label_types'
+ groundtruth_is_crowd = 'groundtruth_is_crowd'
+ groundtruth_area = 'groundtruth_area'
+ groundtruth_difficult = 'groundtruth_difficult'
+ groundtruth_group_of = 'groundtruth_group_of'
+ proposal_boxes = 'proposal_boxes'
+ proposal_objectness = 'proposal_objectness'
+ groundtruth_instance_masks = 'groundtruth_instance_masks'
+ groundtruth_instance_boundaries = 'groundtruth_instance_boundaries'
+ groundtruth_instance_classes = 'groundtruth_instance_classes'
+ groundtruth_keypoints = 'groundtruth_keypoints'
+ groundtruth_keypoint_visibilities = 'groundtruth_keypoint_visibilities'
+ groundtruth_label_weights = 'groundtruth_label_weights'
+ groundtruth_weights = 'groundtruth_weights'
+ num_groundtruth_boxes = 'num_groundtruth_boxes'
+ is_annotated = 'is_annotated'
+ true_image_shape = 'true_image_shape'
+ multiclass_scores = 'multiclass_scores'
+
+
+class DetectionResultFields(object):
+ """Naming conventions for storing the output of the detector.
+
+ Attributes:
+ source_id: source of the original image.
+ key: unique key corresponding to image.
+ detection_boxes: coordinates of the detection boxes in the image.
+ detection_scores: detection scores for the detection boxes in the image.
+ detection_multiclass_scores: class score distribution (including background)
+ for detection boxes in the image including background class.
+ detection_classes: detection-level class labels.
+ detection_masks: contains a segmentation mask for each detection box.
+ detection_boundaries: contains an object boundary for each detection box.
+ detection_keypoints: contains detection keypoints for each detection box.
+ num_detections: number of detections in the batch.
+ raw_detection_boxes: contains decoded detection boxes without Non-Max
+ suppression.
+ raw_detection_scores: contains class score logits for raw detection boxes.
+ detection_anchor_indices: The anchor indices of the detections after NMS.
+ detection_features: contains extracted features for each detected box
+ after NMS.
+ """
+
+ source_id = 'source_id'
+ key = 'key'
+ detection_boxes = 'detection_boxes'
+ detection_scores = 'detection_scores'
+ detection_multiclass_scores = 'detection_multiclass_scores'
+ detection_features = 'detection_features'
+ detection_classes = 'detection_classes'
+ detection_masks = 'detection_masks'
+ detection_boundaries = 'detection_boundaries'
+ detection_keypoints = 'detection_keypoints'
+ num_detections = 'num_detections'
+ raw_detection_boxes = 'raw_detection_boxes'
+ raw_detection_scores = 'raw_detection_scores'
+ detection_anchor_indices = 'detection_anchor_indices'
+
+
+class BoxListFields(object):
+ """Naming conventions for BoxLists.
+
+ Attributes:
+ boxes: bounding box coordinates.
+ classes: classes per bounding box.
+ scores: scores per bounding box.
+ weights: sample weights per bounding box.
+ objectness: objectness score per bounding box.
+ masks: masks per bounding box.
+ boundaries: boundaries per bounding box.
+ keypoints: keypoints per bounding box.
+ keypoint_heatmaps: keypoint heatmaps per bounding box.
+ is_crowd: is_crowd annotation per bounding box.
+ """
+ boxes = 'boxes'
+ classes = 'classes'
+ scores = 'scores'
+ weights = 'weights'
+ confidences = 'confidences'
+ objectness = 'objectness'
+ masks = 'masks'
+ boundaries = 'boundaries'
+ keypoints = 'keypoints'
+ keypoint_heatmaps = 'keypoint_heatmaps'
+ is_crowd = 'is_crowd'
+
+
+class PredictionFields(object):
+ """Naming conventions for standardized prediction outputs.
+
+ Attributes:
+ feature_maps: List of feature maps for prediction.
+ anchors: Generated anchors.
+ raw_detection_boxes: Decoded detection boxes without NMS.
+ raw_detection_feature_map_indices: Feature map indices from which each raw
+ detection box was produced.
+ """
+ feature_maps = 'feature_maps'
+ anchors = 'anchors'
+ raw_detection_boxes = 'raw_detection_boxes'
+ raw_detection_feature_map_indices = 'raw_detection_feature_map_indices'
+
+
+class TfExampleFields(object):
+ """TF-example proto feature names for object detection.
+
+ Holds the standard feature names to load from an Example proto for object
+ detection.
+
+ Attributes:
+ image_encoded: JPEG encoded string
+ image_format: image format, e.g. "JPEG"
+ filename: filename
+ channels: number of channels of image
+ colorspace: colorspace, e.g. "RGB"
+ height: height of image in pixels, e.g. 462
+ width: width of image in pixels, e.g. 581
+ source_id: original source of the image
+ image_class_text: image-level label in text format
+ image_class_label: image-level label in numerical format
+ object_class_text: labels in text format, e.g. ["person", "cat"]
+ object_class_label: labels in numbers, e.g. [16, 8]
+ object_bbox_xmin: xmin coordinates of groundtruth box, e.g. 10, 30
+ object_bbox_xmax: xmax coordinates of groundtruth box, e.g. 50, 40
+ object_bbox_ymin: ymin coordinates of groundtruth box, e.g. 40, 50
+ object_bbox_ymax: ymax coordinates of groundtruth box, e.g. 80, 70
+ object_view: viewpoint of object, e.g. ["frontal", "left"]
+ object_truncated: is object truncated, e.g. [true, false]
+ object_occluded: is object occluded, e.g. [true, false]
+ object_difficult: is object difficult, e.g. [true, false]
+ object_group_of: is object a single object or a group of objects
+ object_depiction: is object a depiction
+ object_is_crowd: [DEPRECATED, use object_group_of instead]
+ is the object a single object or a crowd
+ object_segment_area: the area of the segment.
+ object_weight: a weight factor for the object's bounding box.
+ instance_masks: instance segmentation masks.
+ instance_boundaries: instance boundaries.
+ instance_classes: Classes for each instance segmentation mask.
+ detection_class_label: class label in numbers.
+ detection_bbox_ymin: ymin coordinates of a detection box.
+ detection_bbox_xmin: xmin coordinates of a detection box.
+ detection_bbox_ymax: ymax coordinates of a detection box.
+ detection_bbox_xmax: xmax coordinates of a detection box.
+ detection_score: detection score for the class label and box.
+ """
+ image_encoded = 'image/encoded'
+ image_format = 'image/format' # format is reserved keyword
+ filename = 'image/filename'
+ channels = 'image/channels'
+ colorspace = 'image/colorspace'
+ height = 'image/height'
+ width = 'image/width'
+ source_id = 'image/source_id'
+ image_class_text = 'image/class/text'
+ image_class_label = 'image/class/label'
+ object_class_text = 'image/object/class/text'
+ object_class_label = 'image/object/class/label'
+ object_bbox_ymin = 'image/object/bbox/ymin'
+ object_bbox_xmin = 'image/object/bbox/xmin'
+ object_bbox_ymax = 'image/object/bbox/ymax'
+ object_bbox_xmax = 'image/object/bbox/xmax'
+ object_view = 'image/object/view'
+ object_truncated = 'image/object/truncated'
+ object_occluded = 'image/object/occluded'
+ object_difficult = 'image/object/difficult'
+ object_group_of = 'image/object/group_of'
+ object_depiction = 'image/object/depiction'
+ object_is_crowd = 'image/object/is_crowd'
+ object_segment_area = 'image/object/segment/area'
+ object_weight = 'image/object/weight'
+ instance_masks = 'image/segmentation/object'
+ instance_boundaries = 'image/boundaries/object'
+ instance_classes = 'image/segmentation/object/class'
+ detection_class_label = 'image/detection/label'
+ detection_bbox_ymin = 'image/detection/bbox/ymin'
+ detection_bbox_xmin = 'image/detection/bbox/xmin'
+ detection_bbox_ymax = 'image/detection/bbox/ymax'
+ detection_bbox_xmax = 'image/detection/bbox/xmax'
+ detection_score = 'image/detection/score'
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/target_assigner.py b/Computer Vision/Plant_Disease_Detection_System/core/target_assigner.py
new file mode 100644
index 00000000..3e3ba1ae
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/target_assigner.py
@@ -0,0 +1,707 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base target assigner module.
+
+The job of a TargetAssigner is, for a given set of anchors (bounding boxes) and
+groundtruth detections (bounding boxes), to assign classification and regression
+targets to each anchor as well as weights to each anchor (specifying, e.g.,
+which anchors should not contribute to training loss).
+
+It assigns classification/regression targets by performing the following steps:
+1) Computing pairwise similarity between anchors and groundtruth boxes using a
+ provided RegionSimilarity Calculator
+2) Computing a matching based on the similarity matrix using a provided Matcher
+3) Assigning regression targets based on the matching and a provided BoxCoder
+4) Assigning classification targets based on the matching and groundtruth labels
+
+Note that TargetAssigners only operate on detections from a single
+image at a time, so any logic for applying a TargetAssigner to multiple
+images must be handled externally.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.box_coders import faster_rcnn_box_coder
+from object_detection.box_coders import mean_stddev_box_coder
+from object_detection.core import box_coder
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import matcher as mat
+from object_detection.core import region_similarity_calculator as sim_calc
+from object_detection.core import standard_fields as fields
+from object_detection.matchers import argmax_matcher
+from object_detection.matchers import bipartite_matcher
+from object_detection.utils import shape_utils
+
+
+class TargetAssigner(object):
+ """Target assigner to compute classification and regression targets."""
+
+ def __init__(self,
+ similarity_calc,
+ matcher,
+ box_coder_instance,
+ negative_class_weight=1.0):
+ """Construct Object Detection Target Assigner.
+
+ Args:
+ similarity_calc: a RegionSimilarityCalculator
+ matcher: an object_detection.core.Matcher used to match groundtruth to
+ anchors.
+ box_coder_instance: an object_detection.core.BoxCoder used to encode
+ matching groundtruth boxes with respect to anchors.
+ negative_class_weight: classification weight to be associated to negative
+ anchors (default: 1.0). The weight must be in [0., 1.].
+
+ Raises:
+ ValueError: if similarity_calc is not a RegionSimilarityCalculator or
+ if matcher is not a Matcher or if box_coder is not a BoxCoder
+ """
+ if not isinstance(similarity_calc, sim_calc.RegionSimilarityCalculator):
+ raise ValueError('similarity_calc must be a RegionSimilarityCalculator')
+ if not isinstance(matcher, mat.Matcher):
+ raise ValueError('matcher must be a Matcher')
+ if not isinstance(box_coder_instance, box_coder.BoxCoder):
+ raise ValueError('box_coder must be a BoxCoder')
+ self._similarity_calc = similarity_calc
+ self._matcher = matcher
+ self._box_coder = box_coder_instance
+ self._negative_class_weight = negative_class_weight
+
+ @property
+ def box_coder(self):
+ return self._box_coder
+
+ # TODO(rathodv): move labels, scores, and weights to groundtruth_boxes fields.
+ def assign(self,
+ anchors,
+ groundtruth_boxes,
+ groundtruth_labels=None,
+ unmatched_class_label=None,
+ groundtruth_weights=None):
+ """Assign classification and regression targets to each anchor.
+
+ For a given set of anchors and groundtruth detections, match anchors
+ to groundtruth_boxes and assign classification and regression targets to
+ each anchor as well as weights based on the resulting match (specifying,
+ e.g., which anchors should not contribute to training loss).
+
+ Anchors that are not matched to anything are given a classification target
+ of self._unmatched_cls_target which can be specified via the constructor.
+
+ Args:
+ anchors: a BoxList representing N anchors
+ groundtruth_boxes: a BoxList representing M groundtruth boxes
+ groundtruth_labels: a tensor of shape [M, d_1, ... d_k]
+ with labels for each of the ground_truth boxes. The subshape
+ [d_1, ... d_k] can be empty (corresponding to scalar inputs). When set
+ to None, groundtruth_labels assumes a binary problem where all
+ ground_truth boxes get a positive label (of 1).
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ If set to None, unmatched_cls_target is set to be [0] for each anchor.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box. The weights
+ must be in [0., 1.]. If None, all weights are set to 1. Generally no
+ groundtruth boxes with zero weight match to any anchors as matchers are
+ aware of groundtruth weights. Additionally, `cls_weights` and
+ `reg_weights` are calculated using groundtruth weights as an added
+ safety.
+
+ Returns:
+ cls_targets: a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k],
+ where the subshape [d_1, ..., d_k] is compatible with groundtruth_labels
+ which has shape [num_gt_boxes, d_1, d_2, ... d_k].
+ cls_weights: a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k],
+ representing weights for each element in cls_targets.
+ reg_targets: a float32 tensor with shape [num_anchors, box_code_dimension]
+ reg_weights: a float32 tensor with shape [num_anchors]
+ match: an int32 tensor of shape [num_anchors] containing result of anchor
+ groundtruth matching. Each position in the tensor indicates an anchor
+ and holds the following meaning:
+ (1) if match[i] >= 0, anchor i is matched with groundtruth match[i].
+ (2) if match[i]=-1, anchor i is marked to be background .
+ (3) if match[i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if anchors or groundtruth_boxes are not of type
+ box_list.BoxList
+ """
+ if not isinstance(anchors, box_list.BoxList):
+ raise ValueError('anchors must be an BoxList')
+ if not isinstance(groundtruth_boxes, box_list.BoxList):
+ raise ValueError('groundtruth_boxes must be an BoxList')
+
+ if unmatched_class_label is None:
+ unmatched_class_label = tf.constant([0], tf.float32)
+
+ if groundtruth_labels is None:
+ groundtruth_labels = tf.ones(tf.expand_dims(groundtruth_boxes.num_boxes(),
+ 0))
+ groundtruth_labels = tf.expand_dims(groundtruth_labels, -1)
+
+ unmatched_shape_assert = shape_utils.assert_shape_equal(
+ shape_utils.combined_static_and_dynamic_shape(groundtruth_labels)[1:],
+ shape_utils.combined_static_and_dynamic_shape(unmatched_class_label))
+ labels_and_box_shapes_assert = shape_utils.assert_shape_equal(
+ shape_utils.combined_static_and_dynamic_shape(
+ groundtruth_labels)[:1],
+ shape_utils.combined_static_and_dynamic_shape(
+ groundtruth_boxes.get())[:1])
+
+ if groundtruth_weights is None:
+ num_gt_boxes = groundtruth_boxes.num_boxes_static()
+ if not num_gt_boxes:
+ num_gt_boxes = groundtruth_boxes.num_boxes()
+ groundtruth_weights = tf.ones([num_gt_boxes], dtype=tf.float32)
+
+ # set scores on the gt boxes
+ scores = 1 - groundtruth_labels[:, 0]
+ groundtruth_boxes.add_field(fields.BoxListFields.scores, scores)
+
+ with tf.control_dependencies(
+ [unmatched_shape_assert, labels_and_box_shapes_assert]):
+ match_quality_matrix = self._similarity_calc.compare(groundtruth_boxes,
+ anchors)
+ match = self._matcher.match(match_quality_matrix,
+ valid_rows=tf.greater(groundtruth_weights, 0))
+ reg_targets = self._create_regression_targets(anchors,
+ groundtruth_boxes,
+ match)
+ cls_targets = self._create_classification_targets(groundtruth_labels,
+ unmatched_class_label,
+ match)
+ reg_weights = self._create_regression_weights(match, groundtruth_weights)
+
+ cls_weights = self._create_classification_weights(match,
+ groundtruth_weights)
+ # convert cls_weights from per-anchor to per-class.
+ class_label_shape = tf.shape(cls_targets)[1:]
+ weights_shape = tf.shape(cls_weights)
+ weights_multiple = tf.concat(
+ [tf.ones_like(weights_shape), class_label_shape],
+ axis=0)
+ for _ in range(len(cls_targets.get_shape()[1:])):
+ cls_weights = tf.expand_dims(cls_weights, -1)
+ cls_weights = tf.tile(cls_weights, weights_multiple)
+
+ num_anchors = anchors.num_boxes_static()
+ if num_anchors is not None:
+ reg_targets = self._reset_target_shape(reg_targets, num_anchors)
+ cls_targets = self._reset_target_shape(cls_targets, num_anchors)
+ reg_weights = self._reset_target_shape(reg_weights, num_anchors)
+ cls_weights = self._reset_target_shape(cls_weights, num_anchors)
+
+ return (cls_targets, cls_weights, reg_targets, reg_weights,
+ match.match_results)
+
+ def _reset_target_shape(self, target, num_anchors):
+ """Sets the static shape of the target.
+
+ Args:
+ target: the target tensor. Its first dimension will be overwritten.
+ num_anchors: the number of anchors, which is used to override the target's
+ first dimension.
+
+ Returns:
+ A tensor with the shape info filled in.
+ """
+ target_shape = target.get_shape().as_list()
+ target_shape[0] = num_anchors
+ target.set_shape(target_shape)
+ return target
+
+ def _create_regression_targets(self, anchors, groundtruth_boxes, match):
+ """Returns a regression target for each anchor.
+
+ Args:
+ anchors: a BoxList representing N anchors
+ groundtruth_boxes: a BoxList representing M groundtruth_boxes
+ match: a matcher.Match object
+
+ Returns:
+ reg_targets: a float32 tensor with shape [N, box_code_dimension]
+ """
+ matched_gt_boxes = match.gather_based_on_match(
+ groundtruth_boxes.get(),
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ matched_gt_boxlist = box_list.BoxList(matched_gt_boxes)
+ if groundtruth_boxes.has_field(fields.BoxListFields.keypoints):
+ groundtruth_keypoints = groundtruth_boxes.get_field(
+ fields.BoxListFields.keypoints)
+ matched_keypoints = match.gather_based_on_match(
+ groundtruth_keypoints,
+ unmatched_value=tf.zeros(groundtruth_keypoints.get_shape()[1:]),
+ ignored_value=tf.zeros(groundtruth_keypoints.get_shape()[1:]))
+ matched_gt_boxlist.add_field(fields.BoxListFields.keypoints,
+ matched_keypoints)
+ matched_reg_targets = self._box_coder.encode(matched_gt_boxlist, anchors)
+ match_results_shape = shape_utils.combined_static_and_dynamic_shape(
+ match.match_results)
+
+ # Zero out the unmatched and ignored regression targets.
+ unmatched_ignored_reg_targets = tf.tile(
+ self._default_regression_target(), [match_results_shape[0], 1])
+ matched_anchors_mask = match.matched_column_indicator()
+ reg_targets = tf.where(matched_anchors_mask,
+ matched_reg_targets,
+ unmatched_ignored_reg_targets)
+ return reg_targets
+
+ def _default_regression_target(self):
+ """Returns the default target for anchors to regress to.
+
+ Default regression targets are set to zero (though in
+ this implementation what these targets are set to should
+ not matter as the regression weight of any box set to
+ regress to the default target is zero).
+
+ Returns:
+ default_target: a float32 tensor with shape [1, box_code_dimension]
+ """
+ return tf.constant([self._box_coder.code_size*[0]], tf.float32)
+
+ def _create_classification_targets(self, groundtruth_labels,
+ unmatched_class_label, match):
+ """Create classification targets for each anchor.
+
+ Assign a classification target of for each anchor to the matching
+ groundtruth label that is provided by match. Anchors that are not matched
+ to anything are given the target self._unmatched_cls_target
+
+ Args:
+ groundtruth_labels: a tensor of shape [num_gt_boxes, d_1, ... d_k]
+ with labels for each of the ground_truth boxes. The subshape
+ [d_1, ... d_k] can be empty (corresponding to scalar labels).
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+
+ Returns:
+ a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k], where the
+ subshape [d_1, ..., d_k] is compatible with groundtruth_labels which has
+ shape [num_gt_boxes, d_1, d_2, ... d_k].
+ """
+ return match.gather_based_on_match(
+ groundtruth_labels,
+ unmatched_value=unmatched_class_label,
+ ignored_value=unmatched_class_label)
+
+ def _create_regression_weights(self, match, groundtruth_weights):
+ """Set regression weight for each anchor.
+
+ Only positive anchors are set to contribute to the regression loss, so this
+ method returns a weight of 1 for every positive anchor and 0 for every
+ negative anchor.
+
+ Args:
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box.
+
+ Returns:
+ a float32 tensor with shape [num_anchors] representing regression weights.
+ """
+ return match.gather_based_on_match(
+ groundtruth_weights, ignored_value=0., unmatched_value=0.)
+
+ def _create_classification_weights(self,
+ match,
+ groundtruth_weights):
+ """Create classification weights for each anchor.
+
+ Positive (matched) anchors are associated with a weight of
+ positive_class_weight and negative (unmatched) anchors are associated with
+ a weight of negative_class_weight. When anchors are ignored, weights are set
+ to zero. By default, both positive/negative weights are set to 1.0,
+ but they can be adjusted to handle class imbalance (which is almost always
+ the case in object detection).
+
+ Args:
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box.
+
+ Returns:
+ a float32 tensor with shape [num_anchors] representing classification
+ weights.
+ """
+ return match.gather_based_on_match(
+ groundtruth_weights,
+ ignored_value=0.,
+ unmatched_value=self._negative_class_weight)
+
+ def get_box_coder(self):
+ """Get BoxCoder of this TargetAssigner.
+
+ Returns:
+ BoxCoder object.
+ """
+ return self._box_coder
+
+
+# TODO(rathodv): This method pulls in all the implementation dependencies into
+# core. Therefore its best to have this factory method outside of core.
+def create_target_assigner(reference, stage=None,
+ negative_class_weight=1.0, use_matmul_gather=False):
+ """Factory function for creating standard target assigners.
+
+ Args:
+ reference: string referencing the type of TargetAssigner.
+ stage: string denoting stage: {proposal, detection}.
+ negative_class_weight: classification weight to be associated to negative
+ anchors (default: 1.0)
+ use_matmul_gather: whether to use matrix multiplication based gather which
+ are better suited for TPUs.
+
+ Returns:
+ TargetAssigner: desired target assigner.
+
+ Raises:
+ ValueError: if combination reference+stage is invalid.
+ """
+ if reference == 'Multibox' and stage == 'proposal':
+ similarity_calc = sim_calc.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder_instance = mean_stddev_box_coder.MeanStddevBoxCoder()
+
+ elif reference == 'FasterRCNN' and stage == 'proposal':
+ similarity_calc = sim_calc.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.7,
+ unmatched_threshold=0.3,
+ force_match_for_each_row=True,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder(
+ scale_factors=[10.0, 10.0, 5.0, 5.0])
+
+ elif reference == 'FasterRCNN' and stage == 'detection':
+ similarity_calc = sim_calc.IouSimilarity()
+ # Uses all proposals with IOU < 0.5 as candidate negatives.
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ negatives_lower_than_unmatched=True,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder(
+ scale_factors=[10.0, 10.0, 5.0, 5.0])
+
+ elif reference == 'FastRCNN':
+ similarity_calc = sim_calc.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.1,
+ force_match_for_each_row=False,
+ negatives_lower_than_unmatched=False,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder()
+
+ else:
+ raise ValueError('No valid combination of reference and stage.')
+
+ return TargetAssigner(similarity_calc, matcher, box_coder_instance,
+ negative_class_weight=negative_class_weight)
+
+
+def batch_assign(target_assigner,
+ anchors_batch,
+ gt_box_batch,
+ gt_class_targets_batch,
+ unmatched_class_label=None,
+ gt_weights_batch=None):
+ """Batched assignment of classification and regression targets.
+
+ Args:
+ target_assigner: a target assigner.
+ anchors_batch: BoxList representing N box anchors or list of BoxList objects
+ with length batch_size representing anchor sets.
+ gt_box_batch: a list of BoxList objects with length batch_size
+ representing groundtruth boxes for each image in the batch
+ gt_class_targets_batch: a list of tensors with length batch_size, where
+ each tensor has shape [num_gt_boxes_i, classification_target_size] and
+ num_gt_boxes_i is the number of boxes in the ith boxlist of
+ gt_box_batch.
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ gt_weights_batch: A list of 1-D tf.float32 tensors of shape
+ [num_boxes] containing weights for groundtruth boxes.
+
+ Returns:
+ batch_cls_targets: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_cls_weights: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_reg_targets: a tensor with shape [batch_size, num_anchors,
+ box_code_dimension]
+ batch_reg_weights: a tensor with shape [batch_size, num_anchors],
+ match: an int32 tensor of shape [batch_size, num_anchors] containing result
+ of anchor groundtruth matching. Each position in the tensor indicates an
+ anchor and holds the following meaning:
+ (1) if match[x, i] >= 0, anchor i is matched with groundtruth match[x, i].
+ (2) if match[x, i]=-1, anchor i is marked to be background .
+ (3) if match[x, i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if input list lengths are inconsistent, i.e.,
+ batch_size == len(gt_box_batch) == len(gt_class_targets_batch)
+ and batch_size == len(anchors_batch) unless anchors_batch is a single
+ BoxList.
+ """
+ if not isinstance(anchors_batch, list):
+ anchors_batch = len(gt_box_batch) * [anchors_batch]
+ if not all(
+ isinstance(anchors, box_list.BoxList) for anchors in anchors_batch):
+ raise ValueError('anchors_batch must be a BoxList or list of BoxLists.')
+ if not (len(anchors_batch)
+ == len(gt_box_batch)
+ == len(gt_class_targets_batch)):
+ raise ValueError('batch size incompatible with lengths of anchors_batch, '
+ 'gt_box_batch and gt_class_targets_batch.')
+ cls_targets_list = []
+ cls_weights_list = []
+ reg_targets_list = []
+ reg_weights_list = []
+ match_list = []
+ if gt_weights_batch is None:
+ gt_weights_batch = [None] * len(gt_class_targets_batch)
+ for anchors, gt_boxes, gt_class_targets, gt_weights in zip(
+ anchors_batch, gt_box_batch, gt_class_targets_batch, gt_weights_batch):
+ (cls_targets, cls_weights,
+ reg_targets, reg_weights, match) = target_assigner.assign(
+ anchors, gt_boxes, gt_class_targets, unmatched_class_label, gt_weights)
+ cls_targets_list.append(cls_targets)
+ cls_weights_list.append(cls_weights)
+ reg_targets_list.append(reg_targets)
+ reg_weights_list.append(reg_weights)
+ match_list.append(match)
+ batch_cls_targets = tf.stack(cls_targets_list)
+ batch_cls_weights = tf.stack(cls_weights_list)
+ batch_reg_targets = tf.stack(reg_targets_list)
+ batch_reg_weights = tf.stack(reg_weights_list)
+ batch_match = tf.stack(match_list)
+ return (batch_cls_targets, batch_cls_weights, batch_reg_targets,
+ batch_reg_weights, batch_match)
+
+
+# Assign an alias to avoid large refactor of existing users.
+batch_assign_targets = batch_assign
+
+
+def batch_get_targets(batch_match, groundtruth_tensor_list,
+ groundtruth_weights_list, unmatched_value,
+ unmatched_weight):
+ """Returns targets based on anchor-groundtruth box matching results.
+
+ Args:
+ batch_match: An int32 tensor of shape [batch, num_anchors] containing the
+ result of target assignment returned by TargetAssigner.assign(..).
+ groundtruth_tensor_list: A list of groundtruth tensors of shape
+ [num_groundtruth, d_1, d_2, ..., d_k]. The tensors can be of any type.
+ groundtruth_weights_list: A list of weights, one per groundtruth tensor, of
+ shape [num_groundtruth].
+ unmatched_value: A tensor of shape [d_1, d_2, ..., d_k] of the same type as
+ groundtruth tensor containing target value for anchors that remain
+ unmatched.
+ unmatched_weight: Scalar weight to assign to anchors that remain unmatched.
+
+ Returns:
+ targets: A tensor of shape [batch, num_anchors, d_1, d_2, ..., d_k]
+ containing targets for anchors.
+ weights: A float tensor of shape [batch, num_anchors] containing the weights
+ to assign to each target.
+ """
+ match_list = tf.unstack(batch_match)
+ targets_list = []
+ weights_list = []
+ for match_tensor, groundtruth_tensor, groundtruth_weight in zip(
+ match_list, groundtruth_tensor_list, groundtruth_weights_list):
+ match_object = mat.Match(match_tensor)
+ targets = match_object.gather_based_on_match(
+ groundtruth_tensor,
+ unmatched_value=unmatched_value,
+ ignored_value=unmatched_value)
+ targets_list.append(targets)
+ weights = match_object.gather_based_on_match(
+ groundtruth_weight,
+ unmatched_value=unmatched_weight,
+ ignored_value=tf.zeros_like(unmatched_weight))
+ weights_list.append(weights)
+ return tf.stack(targets_list), tf.stack(weights_list)
+
+
+def batch_assign_confidences(target_assigner,
+ anchors_batch,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ gt_weights_batch=None,
+ unmatched_class_label=None,
+ include_background_class=True,
+ implicit_class_weight=1.0):
+ """Batched assignment of classification and regression targets.
+
+ This differences between batch_assign_confidences and batch_assign_targets:
+ - 'batch_assign_targets' supports scalar (agnostic), vector (multiclass) and
+ tensor (high-dimensional) targets. 'batch_assign_confidences' only support
+ scalar (agnostic) and vector (multiclass) targets.
+ - 'batch_assign_targets' assumes the input class tensor using the binary
+ one/K-hot encoding. 'batch_assign_confidences' takes the class confidence
+ scores as the input, where 1 means positive classes, 0 means implicit
+ negative classes, and -1 means explicit negative classes.
+ - 'batch_assign_confidences' assigns the targets in the similar way as
+ 'batch_assign_targets' except that it gives different weights for implicit
+ and explicit classes. This allows user to control the negative gradients
+ pushed differently for implicit and explicit examples during the training.
+
+ Args:
+ target_assigner: a target assigner.
+ anchors_batch: BoxList representing N box anchors or list of BoxList objects
+ with length batch_size representing anchor sets.
+ gt_box_batch: a list of BoxList objects with length batch_size
+ representing groundtruth boxes for each image in the batch
+ gt_class_confidences_batch: a list of tensors with length batch_size, where
+ each tensor has shape [num_gt_boxes_i, classification_target_size] and
+ num_gt_boxes_i is the number of boxes in the ith boxlist of
+ gt_box_batch. Note that in this tensor, 1 means explicit positive class,
+ -1 means explicit negative class, and 0 means implicit negative class.
+ gt_weights_batch: A list of 1-D tf.float32 tensors of shape
+ [num_gt_boxes_i] containing weights for groundtruth boxes.
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ include_background_class: whether or not gt_class_confidences_batch includes
+ the background class.
+ implicit_class_weight: the weight assigned to implicit examples.
+
+ Returns:
+ batch_cls_targets: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_cls_weights: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_reg_targets: a tensor with shape [batch_size, num_anchors,
+ box_code_dimension]
+ batch_reg_weights: a tensor with shape [batch_size, num_anchors],
+ match: an int32 tensor of shape [batch_size, num_anchors] containing result
+ of anchor groundtruth matching. Each position in the tensor indicates an
+ anchor and holds the following meaning:
+ (1) if match[x, i] >= 0, anchor i is matched with groundtruth match[x, i].
+ (2) if match[x, i]=-1, anchor i is marked to be background .
+ (3) if match[x, i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if input list lengths are inconsistent, i.e.,
+ batch_size == len(gt_box_batch) == len(gt_class_targets_batch)
+ and batch_size == len(anchors_batch) unless anchors_batch is a single
+ BoxList, or if any element in gt_class_confidences_batch has rank > 2.
+ """
+ if not isinstance(anchors_batch, list):
+ anchors_batch = len(gt_box_batch) * [anchors_batch]
+ if not all(
+ isinstance(anchors, box_list.BoxList) for anchors in anchors_batch):
+ raise ValueError('anchors_batch must be a BoxList or list of BoxLists.')
+ if not (len(anchors_batch)
+ == len(gt_box_batch)
+ == len(gt_class_confidences_batch)):
+ raise ValueError('batch size incompatible with lengths of anchors_batch, '
+ 'gt_box_batch and gt_class_confidences_batch.')
+
+ cls_targets_list = []
+ cls_weights_list = []
+ reg_targets_list = []
+ reg_weights_list = []
+ match_list = []
+ if gt_weights_batch is None:
+ gt_weights_batch = [None] * len(gt_class_confidences_batch)
+ for anchors, gt_boxes, gt_class_confidences, gt_weights in zip(
+ anchors_batch, gt_box_batch, gt_class_confidences_batch,
+ gt_weights_batch):
+
+ if (gt_class_confidences is not None and
+ len(gt_class_confidences.get_shape().as_list()) > 2):
+ raise ValueError('The shape of the class target is not supported. ',
+ gt_class_confidences.get_shape())
+
+ cls_targets, _, reg_targets, _, match = target_assigner.assign(
+ anchors, gt_boxes, gt_class_confidences, unmatched_class_label,
+ groundtruth_weights=gt_weights)
+
+ if include_background_class:
+ cls_targets_without_background = tf.slice(
+ cls_targets, [0, 1], [-1, -1])
+ else:
+ cls_targets_without_background = cls_targets
+
+ positive_mask = tf.greater(cls_targets_without_background, 0.0)
+ negative_mask = tf.less(cls_targets_without_background, 0.0)
+ explicit_example_mask = tf.logical_or(positive_mask, negative_mask)
+ positive_anchors = tf.reduce_any(positive_mask, axis=-1)
+
+ regression_weights = tf.cast(positive_anchors, dtype=tf.float32)
+ regression_targets = (
+ reg_targets * tf.expand_dims(regression_weights, axis=-1))
+ regression_weights_expanded = tf.expand_dims(regression_weights, axis=-1)
+
+ cls_targets_without_background = (
+ cls_targets_without_background *
+ (1 - tf.cast(negative_mask, dtype=tf.float32)))
+ cls_weights_without_background = ((1 - implicit_class_weight) * tf.cast(
+ explicit_example_mask, dtype=tf.float32) + implicit_class_weight)
+
+ if include_background_class:
+ cls_weights_background = (
+ (1 - implicit_class_weight) * regression_weights_expanded
+ + implicit_class_weight)
+ classification_weights = tf.concat(
+ [cls_weights_background, cls_weights_without_background], axis=-1)
+ cls_targets_background = 1 - regression_weights_expanded
+ classification_targets = tf.concat(
+ [cls_targets_background, cls_targets_without_background], axis=-1)
+ else:
+ classification_targets = cls_targets_without_background
+ classification_weights = cls_weights_without_background
+
+ cls_targets_list.append(classification_targets)
+ cls_weights_list.append(classification_weights)
+ reg_targets_list.append(regression_targets)
+ reg_weights_list.append(regression_weights)
+ match_list.append(match)
+ batch_cls_targets = tf.stack(cls_targets_list)
+ batch_cls_weights = tf.stack(cls_weights_list)
+ batch_reg_targets = tf.stack(reg_targets_list)
+ batch_reg_weights = tf.stack(reg_weights_list)
+ batch_match = tf.stack(match_list)
+ return (batch_cls_targets, batch_cls_weights, batch_reg_targets,
+ batch_reg_weights, batch_match)
+
+
diff --git a/Computer Vision/Plant_Disease_Detection_System/core/target_assigner_test.py b/Computer Vision/Plant_Disease_Detection_System/core/target_assigner_test.py
new file mode 100644
index 00000000..1ac67f2b
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/core/target_assigner_test.py
@@ -0,0 +1,1232 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.target_assigner."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.box_coders import keypoint_box_coder
+from object_detection.box_coders import mean_stddev_box_coder
+from object_detection.core import box_list
+from object_detection.core import region_similarity_calculator
+from object_detection.core import standard_fields as fields
+from object_detection.core import target_assigner as targetassigner
+from object_detection.matchers import argmax_matcher
+from object_detection.matchers import bipartite_matcher
+from object_detection.utils import test_case
+
+
+class TargetAssignerTest(test_case.TestCase):
+
+ def test_assign_agnostic(self):
+ def graph_fn(anchor_means, groundtruth_box_corners):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_class_agnostic_with_ignored_matches(self):
+ # Note: test is very similar to above. The third box matched with an IOU
+ # of 0.35, which is between the matched and unmatched threshold. This means
+ # That like above the expected classification targets are [1, 1, 0].
+ # Unlike above, the third target is ignored and therefore expected
+ # classification weights are [1, 1, 0].
+ def graph_fn(anchor_means, groundtruth_box_corners):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.3)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9]], dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [0]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_agnostic_with_keypoints(self):
+ def graph_fn(anchor_means, groundtruth_box_corners,
+ groundtruth_keypoints):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = keypoint_box_coder.KeypointBoxCoder(
+ num_keypoints=6, scale_factors=[10.0, 10.0, 5.0, 5.0])
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ groundtruth_boxlist.add_field(fields.BoxListFields.keypoints,
+ groundtruth_keypoints)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 1.0],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.45, 0.45, 0.95, 0.95]],
+ dtype=np.float32)
+ groundtruth_keypoints = np.array(
+ [[[0.1, 0.2], [0.1, 0.3], [0.2, 0.2], [0.2, 0.2], [0.1, 0.1], [0.9, 0]],
+ [[0, 0.3], [0.2, 0.4], [0.5, 0.6], [0, 0.6], [0.8, 0.2], [0.2, 0.4]]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0, -3, -1, -3, 1, -1, -1, -1, -1, -3, -3, 13,
+ -5],
+ [-1, -1, 0, 0, -15, -9, -11, -7, -5, -3, -15, -3, 1, -11,
+ -11, -7],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [anchor_means,
+ groundtruth_box_corners,
+ groundtruth_keypoints])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_class_agnostic_with_keypoints_and_ignored_matches(self):
+ # Note: test is very similar to above. The third box matched with an IOU
+ # of 0.35, which is between the matched and unmatched threshold. This means
+ # That like above the expected classification targets are [1, 1, 0].
+ # Unlike above, the third target is ignored and therefore expected
+ # classification weights are [1, 1, 0].
+ def graph_fn(anchor_means, groundtruth_box_corners,
+ groundtruth_keypoints):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = keypoint_box_coder.KeypointBoxCoder(
+ num_keypoints=6, scale_factors=[10.0, 10.0, 5.0, 5.0])
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ groundtruth_boxlist.add_field(fields.BoxListFields.keypoints,
+ groundtruth_keypoints)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 1.0],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.45, 0.45, 0.95, 0.95]],
+ dtype=np.float32)
+ groundtruth_keypoints = np.array(
+ [[[0.1, 0.2], [0.1, 0.3], [0.2, 0.2], [0.2, 0.2], [0.1, 0.1], [0.9, 0]],
+ [[0, 0.3], [0.2, 0.4], [0.5, 0.6], [0, 0.6], [0.8, 0.2], [0.2, 0.4]]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0, -3, -1, -3, 1, -1, -1, -1, -1, -3, -3, 13,
+ -5],
+ [-1, -1, 0, 0, -15, -9, -11, -7, -5, -3, -15, -3, 1, -11,
+ -11, -7],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [anchor_means,
+ groundtruth_box_corners,
+ groundtruth_keypoints])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_multiclass(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+ groundtruth_labels = np.array([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], dtype=np.float32)
+
+ exp_cls_targets = [[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [1, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 1, 0, 0, 0]]
+ exp_cls_weights = [[1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0],
+ [0, 0, -.5, .2]]
+ exp_reg_weights = [1, 1, 0, 1]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_multiclass_with_groundtruth_weights(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels,
+ groundtruth_weights):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label,
+ groundtruth_weights=groundtruth_weights)
+ (_, cls_weights, _, reg_weights, _) = result
+ return (cls_weights, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+ groundtruth_labels = np.array([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], dtype=np.float32)
+ groundtruth_weights = np.array([0.3, 0., 0.5], dtype=np.float32)
+
+ # background class gets weight of 1.
+ exp_cls_weights = [[0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
+ [0, 0, 0, 0, 0, 0, 0],
+ [1, 1, 1, 1, 1, 1, 1],
+ [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]]
+ exp_reg_weights = [0.3, 0., 0., 0.5] # background class gets weight of 0.
+
+ (cls_weights_out, reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_box_corners, groundtruth_labels,
+ groundtruth_weights
+ ])
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_assign_multidimensional_class_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+
+ unmatched_class_label = tf.constant([[0, 0], [0, 0]], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+
+ groundtruth_labels = np.array([[[0, 1], [1, 0]],
+ [[1, 0], [0, 1]],
+ [[0, 1], [1, .5]]], np.float32)
+
+ exp_cls_targets = [[[0, 1], [1, 0]],
+ [[1, 0], [0, 1]],
+ [[0, 0], [0, 0]],
+ [[0, 1], [1, .5]]]
+ exp_cls_weights = [[[1, 1], [1, 1]],
+ [[1, 1], [1, 1]],
+ [[1, 1], [1, 1]],
+ [[1, 1], [1, 1]]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0],
+ [0, 0, -.5, .2]]
+ exp_reg_weights = [1, 1, 0, 1]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([0, 0, 0], tf.float32)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ groundtruth_labels = np.zeros((0, 3), dtype=np.float32)
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]],
+ dtype=np.float32)
+ exp_cls_targets = [[0, 0, 0],
+ [0, 0, 0],
+ [0, 0, 0],
+ [0, 0, 0]]
+ exp_cls_weights = [[1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [0, 0, 0, 0]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_raises_error_on_incompatible_groundtruth_boxes_and_labels(self):
+ similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder()
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ prior_means = tf.constant([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]])
+ priors = box_list.BoxList(prior_means)
+
+ box_corners = [[0.0, 0.0, 0.5, 0.5],
+ [0.0, 0.0, 0.5, 0.8],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+
+ groundtruth_labels = tf.constant([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], tf.float32)
+ with self.assertRaisesRegexp(ValueError, 'Unequal shapes'):
+ target_assigner.assign(
+ priors,
+ boxes,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+
+ def test_raises_error_on_invalid_groundtruth_labels(self):
+ similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=1.0)
+ unmatched_class_label = tf.constant([[0, 0], [0, 0], [0, 0]], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ prior_means = tf.constant([[0.0, 0.0, 0.5, 0.5]])
+ priors = box_list.BoxList(prior_means)
+
+ box_corners = [[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+ groundtruth_labels = tf.constant([[[0, 1], [1, 0]]], tf.float32)
+
+ with self.assertRaises(ValueError):
+ target_assigner.assign(
+ priors,
+ boxes,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+
+
+class BatchTargetAssignerTest(test_case.TestCase):
+
+ def _get_target_assigner(self):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ return targetassigner.TargetAssigner(similarity_calc, matcher, box_coder)
+
+ def test_batch_assign_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [None, None]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ agnostic_target_assigner = self._get_target_assigner()
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ agnostic_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[1], [0], [0], [0]],
+ [[0], [1], [1], [0]]]
+ exp_cls_weights = [[[1], [1], [1], [1]],
+ [[1], [1], [1], [1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_boxlist1, groundtruth_boxlist2])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multiclass_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]],
+ [[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multiclass_targets_with_padded_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ gt_weights = [groundtruth_weights1, groundtruth_weights2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label, gt_weights)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2],
+ [0., 0., 0., 0.]], dtype=np.float32)
+ groundtruth_weights1 = np.array([1, 0], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842],
+ [0, 0, 0, 0]],
+ dtype=np.float32)
+ groundtruth_weights2 = np.array([1, 1, 0], dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0], [0, 0, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [0, 0, 0, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]],
+ [[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multidimensional_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ target_dimensions = (2, 3)
+ unmatched_class_label = tf.constant(np.zeros(target_dimensions),
+ tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[[0, 1, 1],
+ [1, 1, 0]]], dtype=np.float32)
+ class_targets2 = np.array([[[0, 1, 1],
+ [1, 1, 0]],
+ [[0, 0, 1],
+ [0, 0, 1]]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[[0., 1., 1.],
+ [1., 1., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]]],
+ [[[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 1., 1.],
+ [1., 1., 0.]],
+ [[0., 0., 1.],
+ [0., 0., 1.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]]]]
+ exp_cls_weights = [[[[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]]],
+ [[[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, gt_class_targets):
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ gt_box_batch = [groundtruth_boxlist]
+ gt_class_targets_batch = [gt_class_targets]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist,
+ gt_box_batch, gt_class_targets_batch, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[0, 0]]
+ num_classes = 3
+ pad = 1
+ gt_class_targets = np.zeros((0, num_classes + pad), dtype=np.float32)
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, gt_class_targets])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+
+class BatchGetTargetsTest(test_case.TestCase):
+
+ def test_scalar_targets(self):
+ batch_match = np.array([[1, 0, 1],
+ [-2, -1, 1]], dtype=np.int32)
+ groundtruth_tensors_list = np.array([[11, 12], [13, 14]], dtype=np.int32)
+ groundtruth_weights_list = np.array([[1.0, 1.0], [1.0, 0.5]],
+ dtype=np.float32)
+ unmatched_value = np.array(99, dtype=np.int32)
+ unmatched_weight = np.array(0.0, dtype=np.float32)
+
+ def graph_fn(batch_match, groundtruth_tensors_list,
+ groundtruth_weights_list, unmatched_value, unmatched_weight):
+ targets, weights = targetassigner.batch_get_targets(
+ batch_match, tf.unstack(groundtruth_tensors_list),
+ tf.unstack(groundtruth_weights_list),
+ unmatched_value, unmatched_weight)
+ return (targets, weights)
+
+ (targets_np, weights_np) = self.execute(graph_fn, [
+ batch_match, groundtruth_tensors_list, groundtruth_weights_list,
+ unmatched_value, unmatched_weight
+ ])
+ self.assertAllEqual([[12, 11, 12],
+ [99, 99, 14]], targets_np)
+ self.assertAllClose([[1.0, 1.0, 1.0],
+ [0.0, 0.0, 0.5]], weights_np)
+
+ def test_1d_targets(self):
+ batch_match = np.array([[1, 0, 1],
+ [-2, -1, 1]], dtype=np.int32)
+ groundtruth_tensors_list = np.array([[[11, 12], [12, 13]],
+ [[13, 14], [14, 15]]],
+ dtype=np.float32)
+ groundtruth_weights_list = np.array([[1.0, 1.0], [1.0, 0.5]],
+ dtype=np.float32)
+ unmatched_value = np.array([99, 99], dtype=np.float32)
+ unmatched_weight = np.array(0.0, dtype=np.float32)
+
+ def graph_fn(batch_match, groundtruth_tensors_list,
+ groundtruth_weights_list, unmatched_value, unmatched_weight):
+ targets, weights = targetassigner.batch_get_targets(
+ batch_match, tf.unstack(groundtruth_tensors_list),
+ tf.unstack(groundtruth_weights_list),
+ unmatched_value, unmatched_weight)
+ return (targets, weights)
+
+ (targets_np, weights_np) = self.execute(graph_fn, [
+ batch_match, groundtruth_tensors_list, groundtruth_weights_list,
+ unmatched_value, unmatched_weight
+ ])
+ self.assertAllClose([[[12, 13], [11, 12], [12, 13]],
+ [[99, 99], [99, 99], [14, 15]]], targets_np)
+ self.assertAllClose([[1.0, 1.0, 1.0],
+ [0.0, 0.0, 0.5]], weights_np)
+
+
+class BatchTargetAssignConfidencesTest(test_case.TestCase):
+
+ def _get_target_assigner(self):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ return targetassigner.TargetAssigner(similarity_calc, matcher, box_coder)
+
+ def test_batch_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, gt_class_confidences):
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ gt_box_batch = [groundtruth_boxlist]
+ gt_class_confidences_batch = [gt_class_confidences]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+
+ num_classes = 3
+ implicit_class_weight = 0.5
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ multiclass_target_assigner = self._get_target_assigner()
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1]], dtype=np.float32)
+ num_classes = 3
+ pad = 1
+ gt_class_confidences = np.zeros((0, num_classes + pad), dtype=np.float32)
+
+ exp_cls_targets = [[[1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[0, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn,
+ [anchor_means, groundtruth_box_corners, gt_class_confidences])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_agnostic(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [None, None]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ agnostic_target_assigner = self._get_target_assigner()
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ agnostic_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ include_background_class=False,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[1], [0], [0], [0]],
+ [[0], [1], [1], [0]]]
+ exp_cls_weights = [[[1], [0.5], [0.5], [0.5]],
+ [[0.5], [1], [1], [0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_boxlist1, groundtruth_boxlist2])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multiclass(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ implicit_class_weight = 0.5
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, -1, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]],
+ [[0.5, 0.5, 0.5, 0.5],
+ [1, 0.5, 0.5, 1],
+ [0.5, 0.5, 1, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 0, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multiclass_with_padded_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ gt_weights = [groundtruth_weights1, groundtruth_weights2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ gt_weights,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2],
+ [0., 0., 0., 0.]], dtype=np.float32)
+ groundtruth_weights1 = np.array([1, 0], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842],
+ [0, 0, 0, 0]],
+ dtype=np.float32)
+ groundtruth_weights2 = np.array([1, 1, 0], dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0], [0, 0, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, -1, 0],
+ [0, 0, 0, 0]], dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]],
+ [[0.5, 0.5, 0.5, 0.5],
+ [1, 0.5, 0.5, 1],
+ [0.5, 0.5, 1, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 0, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multidimensional(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ target_dimensions = (2, 3)
+ unmatched_class_label = tf.constant(np.zeros(target_dimensions),
+ tf.float32)
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0]], dtype=np.float32)
+ class_targets1 = np.array([[[0, 1, 1],
+ [1, 1, 0]]], dtype=np.float32)
+ class_targets2 = np.array([[[0, 1, 1],
+ [1, 1, 0]],
+ [[0, 0, 1],
+ [0, 0, 1]]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ with self.assertRaises(ValueError):
+ _, _, _, _ = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+
+
+class CreateTargetAssignerTest(tf.test.TestCase):
+
+ def test_create_target_assigner(self):
+ """Tests that named constructor gives working target assigners.
+
+ TODO(rathodv): Make this test more general.
+ """
+ corners = [[0.0, 0.0, 1.0, 1.0]]
+ groundtruth = box_list.BoxList(tf.constant(corners))
+
+ priors = box_list.BoxList(tf.constant(corners))
+ multibox_ta = (targetassigner
+ .create_target_assigner('Multibox', stage='proposal'))
+ multibox_ta.assign(priors, groundtruth)
+ # No tests on output, as that may vary arbitrarily as new target assigners
+ # are added. As long as it is constructed correctly and runs without errors,
+ # tests on the individual assigners cover correctness of the assignments.
+
+ anchors = box_list.BoxList(tf.constant(corners))
+ faster_rcnn_proposals_ta = (targetassigner
+ .create_target_assigner('FasterRCNN',
+ stage='proposal'))
+ faster_rcnn_proposals_ta.assign(anchors, groundtruth)
+
+ fast_rcnn_ta = (targetassigner
+ .create_target_assigner('FastRCNN'))
+ fast_rcnn_ta.assign(anchors, groundtruth)
+
+ faster_rcnn_detection_ta = (targetassigner
+ .create_target_assigner('FasterRCNN',
+ stage='detection'))
+ faster_rcnn_detection_ta.assign(anchors, groundtruth)
+
+ with self.assertRaises(ValueError):
+ targetassigner.create_target_assigner('InvalidDetector',
+ stage='invalid_stage')
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/doc/about.md b/Computer Vision/Plant_Disease_Detection_System/doc/about.md
new file mode 100644
index 00000000..766ddd19
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/doc/about.md
@@ -0,0 +1,45 @@
+## About Project
+
+An application that facilitates farmers, scientists and botanists to detect the type of plant or crops, detect any kind of diseases in them. The app sends the image of the plant to the server where it is analysed using CNN classifier model. Once detected, the disease and its solutions are displayed to the user.
+
+---
+
+## Model
+
+Trained to identify 5 classes for **Disease Detection** and 24 classes for **Disease Classification**
+
+ - Disease Classification Classes
+
+ - Apple___Apple_scab
+ - Apple___Black_rot
+ - Apple___Cedar_apple_rust
+ - Apple___healthy
+ - Blueberry___healthy
+ - Cherry___healthy
+ - Cherry___Powdery_mildew
+ - Grape___Black_rot
+ - Grape___Esca_Black_Measles
+ - Grape___healthy
+ - Grape___Leaf_blight_Isariopsis_Leaf_Spot
+ - Orange___Haunglongbing
+ - Peach___Bacterial_spot
+ - Peach___healthy
+ - Pepper,_bell___Bacterial_spot
+ - Pepper,_bell___healthy
+ - Potato___Early_blight
+ - Potato___healthy
+ - Raspberry___healthy
+ - Soybean___healthy
+ - Squash___Powdery_mildew
+ - Strawberry___healthy
+ - Strawberry___Leaf_scorch
+
+ - Disease Detection Classes
+
+ - Cherry___healthy
+ - Cherry___Powdery_mildew
+ - Grape___Black_rot
+ - Grape___Esca_Black_Measles
+ - Grape___healthy
+ - Grape___Leaf_blight_Isariopsis_Leaf_Spot
+---
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_classification/images/out.jpg b/Computer Vision/Plant_Disease_Detection_System/object_classification/images/out.jpg
new file mode 100644
index 00000000..c8b1f38b
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_classification/images/out.jpg differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_classification/rps.h5 b/Computer Vision/Plant_Disease_Detection_System/object_classification/rps.h5
new file mode 100644
index 00000000..aba26184
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_classification/rps.h5 differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__init__.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-35.pyc
new file mode 100644
index 00000000..8b169253
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-36.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 00000000..52ab3789
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/__init__.cpython-36.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/anchor_generator.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/anchor_generator.cpython-35.pyc
new file mode 100644
index 00000000..89073dd0
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/anchor_generator.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/balanced_positive_negative_sampler.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/balanced_positive_negative_sampler.cpython-35.pyc
new file mode 100644
index 00000000..f887359d
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/balanced_positive_negative_sampler.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/batcher.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/batcher.cpython-35.pyc
new file mode 100644
index 00000000..6b6d05f1
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/batcher.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_coder.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_coder.cpython-35.pyc
new file mode 100644
index 00000000..96c228cd
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_coder.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list.cpython-35.pyc
new file mode 100644
index 00000000..6e94f2e4
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list_ops.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list_ops.cpython-35.pyc
new file mode 100644
index 00000000..02180db6
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_list_ops.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_predictor.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_predictor.cpython-35.pyc
new file mode 100644
index 00000000..838a2ba4
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/box_predictor.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/data_decoder.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/data_decoder.cpython-35.pyc
new file mode 100644
index 00000000..fe7ce4a3
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/data_decoder.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/freezable_batch_norm.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/freezable_batch_norm.cpython-35.pyc
new file mode 100644
index 00000000..6d0195da
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/freezable_batch_norm.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/keypoint_ops.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/keypoint_ops.cpython-35.pyc
new file mode 100644
index 00000000..70620651
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/keypoint_ops.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/losses.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/losses.cpython-35.pyc
new file mode 100644
index 00000000..729eb4e6
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/losses.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/matcher.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/matcher.cpython-35.pyc
new file mode 100644
index 00000000..8ac71bc6
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/matcher.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/minibatch_sampler.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/minibatch_sampler.cpython-35.pyc
new file mode 100644
index 00000000..9a062896
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/minibatch_sampler.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/model.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/model.cpython-35.pyc
new file mode 100644
index 00000000..bcdc1826
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/model.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/post_processing.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/post_processing.cpython-35.pyc
new file mode 100644
index 00000000..9ea0167d
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/post_processing.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/prefetcher.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/prefetcher.cpython-35.pyc
new file mode 100644
index 00000000..b168d2e0
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/prefetcher.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor.cpython-35.pyc
new file mode 100644
index 00000000..82008057
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor_cache.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor_cache.cpython-35.pyc
new file mode 100644
index 00000000..c7b7c3d4
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/preprocessor_cache.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/region_similarity_calculator.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/region_similarity_calculator.cpython-35.pyc
new file mode 100644
index 00000000..b99a00d8
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/region_similarity_calculator.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-35.pyc
new file mode 100644
index 00000000..9ef45320
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-36.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-36.pyc
new file mode 100644
index 00000000..d4efc38a
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/standard_fields.cpython-36.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/target_assigner.cpython-35.pyc b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/target_assigner.cpython-35.pyc
new file mode 100644
index 00000000..05fe940c
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/__pycache__/target_assigner.cpython-35.pyc differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/anchor_generator.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/anchor_generator.py
new file mode 100644
index 00000000..070b1d68
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/anchor_generator.py
@@ -0,0 +1,171 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base anchor generator.
+
+The job of the anchor generator is to create (or load) a collection
+of bounding boxes to be used as anchors.
+
+Generated anchors are assumed to match some convolutional grid or list of grid
+shapes. For example, we might want to generate anchors matching an 8x8
+feature map and a 4x4 feature map. If we place 3 anchors per grid location
+on the first feature map and 6 anchors per grid location on the second feature
+map, then 3*8*8 + 6*4*4 = 288 anchors are generated in total.
+
+To support fully convolutional settings, feature map shapes are passed
+dynamically at generation time. The number of anchors to place at each location
+is static --- implementations of AnchorGenerator must always be able return
+the number of anchors that it uses per location for each feature map.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+from six.moves import zip
+import tensorflow as tf
+
+
+class AnchorGenerator(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for anchor generators."""
+
+ @abstractmethod
+ def name_scope(self):
+ """Name scope.
+
+ Must be defined by implementations.
+
+ Returns:
+ a string representing the name scope of the anchor generation operation.
+ """
+ pass
+
+ @property
+ def check_num_anchors(self):
+ """Whether to dynamically check the number of anchors generated.
+
+ Can be overridden by implementations that would like to disable this
+ behavior.
+
+ Returns:
+ a boolean controlling whether the Generate function should dynamically
+ check the number of anchors generated against the mathematically
+ expected number of anchors.
+ """
+ return True
+
+ @abstractmethod
+ def num_anchors_per_location(self):
+ """Returns the number of anchors per spatial location.
+
+ Returns:
+ a list of integers, one for each expected feature map to be passed to
+ the `generate` function.
+ """
+ pass
+
+ def generate(self, feature_map_shape_list, **params):
+ """Generates a collection of bounding boxes to be used as anchors.
+
+ TODO(rathodv): remove **params from argument list and make stride and
+ offsets (for multiple_grid_anchor_generator) constructor arguments.
+
+ Args:
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with. Pairs can be provided as 1-dimensional
+ integer tensors of length 2 or simply as tuples of integers.
+ **params: parameters for anchor generation op
+
+ Returns:
+ boxes_list: a list of BoxLists each holding anchor boxes corresponding to
+ the input feature map shapes.
+
+ Raises:
+ ValueError: if the number of feature map shapes does not match the length
+ of NumAnchorsPerLocation.
+ """
+ if self.check_num_anchors and (
+ len(feature_map_shape_list) != len(self.num_anchors_per_location())):
+ raise ValueError('Number of feature maps is expected to equal the length '
+ 'of `num_anchors_per_location`.')
+ with tf.name_scope(self.name_scope()):
+ anchors_list = self._generate(feature_map_shape_list, **params)
+ if self.check_num_anchors:
+ with tf.control_dependencies([
+ self._assert_correct_number_of_anchors(
+ anchors_list, feature_map_shape_list)]):
+ for item in anchors_list:
+ item.set(tf.identity(item.get()))
+ return anchors_list
+
+ @abstractmethod
+ def _generate(self, feature_map_shape_list, **params):
+ """To be overridden by implementations.
+
+ Args:
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with.
+ **params: parameters for anchor generation op
+
+ Returns:
+ boxes_list: a list of BoxList, each holding a collection of N anchor
+ boxes.
+ """
+ pass
+
+ def anchor_index_to_feature_map_index(self, boxlist_list):
+ """Returns a 1-D array of feature map indices for each anchor.
+
+ Args:
+ boxlist_list: a list of Boxlist, each holding a collection of N anchor
+ boxes. This list is produced in self.generate().
+
+ Returns:
+ A [num_anchors] integer array, where each element indicates which feature
+ map index the anchor belongs to.
+ """
+ feature_map_indices_list = []
+ for i, boxes in enumerate(boxlist_list):
+ feature_map_indices_list.append(
+ i * tf.ones([boxes.num_boxes()], dtype=tf.int32))
+ return tf.concat(feature_map_indices_list, axis=0)
+
+ def _assert_correct_number_of_anchors(self, anchors_list,
+ feature_map_shape_list):
+ """Assert that correct number of anchors was generated.
+
+ Args:
+ anchors_list: A list of box_list.BoxList object holding anchors generated.
+ feature_map_shape_list: list of (height, width) pairs in the format
+ [(height_0, width_0), (height_1, width_1), ...] that the generated
+ anchors must align with.
+ Returns:
+ Op that raises InvalidArgumentError if the number of anchors does not
+ match the number of expected anchors.
+ """
+ expected_num_anchors = 0
+ actual_num_anchors = 0
+ for num_anchors_per_location, feature_map_shape, anchors in zip(
+ self.num_anchors_per_location(), feature_map_shape_list, anchors_list):
+ expected_num_anchors += (num_anchors_per_location
+ * feature_map_shape[0]
+ * feature_map_shape[1])
+ actual_num_anchors += anchors.num_boxes()
+ return tf.assert_equal(expected_num_anchors, actual_num_anchors)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler.py
new file mode 100644
index 00000000..89c1fc7f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler.py
@@ -0,0 +1,266 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Class to subsample minibatches by balancing positives and negatives.
+
+Subsamples minibatches based on a pre-specified positive fraction in range
+[0,1]. The class presumes there are many more negatives than positive examples:
+if the desired batch_size cannot be achieved with the pre-specified positive
+fraction, it fills the rest with negative examples. If this is not sufficient
+for obtaining the desired batch_size, it returns fewer examples.
+
+The main function to call is Subsample(self, indicator, labels). For convenience
+one can also call SubsampleWeights(self, weights, labels) which is defined in
+the minibatch_sampler base class.
+
+When is_static is True, it implements a method that guarantees static shapes.
+It also ensures the length of output of the subsample is always batch_size, even
+when number of examples set to True in indicator is less than batch_size.
+"""
+
+import tensorflow as tf
+
+from object_detection.core import minibatch_sampler
+from object_detection.utils import ops
+
+
+class BalancedPositiveNegativeSampler(minibatch_sampler.MinibatchSampler):
+ """Subsamples minibatches to a desired balance of positives and negatives."""
+
+ def __init__(self, positive_fraction=0.5, is_static=False):
+ """Constructs a minibatch sampler.
+
+ Args:
+ positive_fraction: desired fraction of positive examples (scalar in [0,1])
+ in the batch.
+ is_static: If True, uses an implementation with static shape guarantees.
+
+ Raises:
+ ValueError: if positive_fraction < 0, or positive_fraction > 1
+ """
+ if positive_fraction < 0 or positive_fraction > 1:
+ raise ValueError('positive_fraction should be in range [0,1]. '
+ 'Received: %s.' % positive_fraction)
+ self._positive_fraction = positive_fraction
+ self._is_static = is_static
+
+ def _get_num_pos_neg_samples(self, sorted_indices_tensor, sample_size):
+ """Counts the number of positives and negatives numbers to be sampled.
+
+ Args:
+ sorted_indices_tensor: A sorted int32 tensor of shape [N] which contains
+ the signed indices of the examples where the sign is based on the label
+ value. The examples that cannot be sampled are set to 0. It samples
+ atmost sample_size*positive_fraction positive examples and remaining
+ from negative examples.
+ sample_size: Size of subsamples.
+
+ Returns:
+ A tuple containing the number of positive and negative labels in the
+ subsample.
+ """
+ input_length = tf.shape(sorted_indices_tensor)[0]
+ valid_positive_index = tf.greater(sorted_indices_tensor,
+ tf.zeros(input_length, tf.int32))
+ num_sampled_pos = tf.reduce_sum(tf.cast(valid_positive_index, tf.int32))
+ max_num_positive_samples = tf.constant(
+ int(sample_size * self._positive_fraction), tf.int32)
+ num_positive_samples = tf.minimum(max_num_positive_samples, num_sampled_pos)
+ num_negative_samples = tf.constant(sample_size,
+ tf.int32) - num_positive_samples
+
+ return num_positive_samples, num_negative_samples
+
+ def _get_values_from_start_and_end(self, input_tensor, num_start_samples,
+ num_end_samples, total_num_samples):
+ """slices num_start_samples and last num_end_samples from input_tensor.
+
+ Args:
+ input_tensor: An int32 tensor of shape [N] to be sliced.
+ num_start_samples: Number of examples to be sliced from the beginning
+ of the input tensor.
+ num_end_samples: Number of examples to be sliced from the end of the
+ input tensor.
+ total_num_samples: Sum of is num_start_samples and num_end_samples. This
+ should be a scalar.
+
+ Returns:
+ A tensor containing the first num_start_samples and last num_end_samples
+ from input_tensor.
+
+ """
+ input_length = tf.shape(input_tensor)[0]
+ start_positions = tf.less(tf.range(input_length), num_start_samples)
+ end_positions = tf.greater_equal(
+ tf.range(input_length), input_length - num_end_samples)
+ selected_positions = tf.logical_or(start_positions, end_positions)
+ selected_positions = tf.cast(selected_positions, tf.float32)
+ indexed_positions = tf.multiply(tf.cumsum(selected_positions),
+ selected_positions)
+ one_hot_selector = tf.one_hot(tf.cast(indexed_positions, tf.int32) - 1,
+ total_num_samples,
+ dtype=tf.float32)
+ return tf.cast(tf.tensordot(tf.cast(input_tensor, tf.float32),
+ one_hot_selector, axes=[0, 0]), tf.int32)
+
+ def _static_subsample(self, indicator, batch_size, labels):
+ """Returns subsampled minibatch.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ N should be a complie time constant.
+ batch_size: desired batch size. This scalar cannot be None.
+ labels: boolean tensor of shape [N] denoting positive(=True) and negative
+ (=False) examples. N should be a complie time constant.
+
+ Returns:
+ sampled_idx_indicator: boolean tensor of shape [N], True for entries which
+ are sampled. It ensures the length of output of the subsample is always
+ batch_size, even when number of examples set to True in indicator is
+ less than batch_size.
+
+ Raises:
+ ValueError: if labels and indicator are not 1D boolean tensors.
+ """
+ # Check if indicator and labels have a static size.
+ if not indicator.shape.is_fully_defined():
+ raise ValueError('indicator must be static in shape when is_static is'
+ 'True')
+ if not labels.shape.is_fully_defined():
+ raise ValueError('labels must be static in shape when is_static is'
+ 'True')
+ if not isinstance(batch_size, int):
+ raise ValueError('batch_size has to be an integer when is_static is'
+ 'True.')
+
+ input_length = tf.shape(indicator)[0]
+
+ # Set the number of examples set True in indicator to be at least
+ # batch_size.
+ num_true_sampled = tf.reduce_sum(tf.cast(indicator, tf.float32))
+ additional_false_sample = tf.less_equal(
+ tf.cumsum(tf.cast(tf.logical_not(indicator), tf.float32)),
+ batch_size - num_true_sampled)
+ indicator = tf.logical_or(indicator, additional_false_sample)
+
+ # Shuffle indicator and label. Need to store the permutation to restore the
+ # order post sampling.
+ permutation = tf.random_shuffle(tf.range(input_length))
+ indicator = ops.matmul_gather_on_zeroth_axis(
+ tf.cast(indicator, tf.float32), permutation)
+ labels = ops.matmul_gather_on_zeroth_axis(
+ tf.cast(labels, tf.float32), permutation)
+
+ # index (starting from 1) when indicator is True, 0 when False
+ indicator_idx = tf.where(
+ tf.cast(indicator, tf.bool), tf.range(1, input_length + 1),
+ tf.zeros(input_length, tf.int32))
+
+ # Replace -1 for negative, +1 for positive labels
+ signed_label = tf.where(
+ tf.cast(labels, tf.bool), tf.ones(input_length, tf.int32),
+ tf.scalar_mul(-1, tf.ones(input_length, tf.int32)))
+ # negative of index for negative label, positive index for positive label,
+ # 0 when indicator is False.
+ signed_indicator_idx = tf.multiply(indicator_idx, signed_label)
+ sorted_signed_indicator_idx = tf.nn.top_k(
+ signed_indicator_idx, input_length, sorted=True).values
+
+ [num_positive_samples,
+ num_negative_samples] = self._get_num_pos_neg_samples(
+ sorted_signed_indicator_idx, batch_size)
+
+ sampled_idx = self._get_values_from_start_and_end(
+ sorted_signed_indicator_idx, num_positive_samples,
+ num_negative_samples, batch_size)
+
+ # Shift the indices to start from 0 and remove any samples that are set as
+ # False.
+ sampled_idx = tf.abs(sampled_idx) - tf.ones(batch_size, tf.int32)
+ sampled_idx = tf.multiply(
+ tf.cast(tf.greater_equal(sampled_idx, tf.constant(0)), tf.int32),
+ sampled_idx)
+
+ sampled_idx_indicator = tf.cast(tf.reduce_sum(
+ tf.one_hot(sampled_idx, depth=input_length),
+ axis=0), tf.bool)
+
+ # project back the order based on stored permutations
+ reprojections = tf.one_hot(permutation, depth=input_length,
+ dtype=tf.float32)
+ return tf.cast(tf.tensordot(
+ tf.cast(sampled_idx_indicator, tf.float32),
+ reprojections, axes=[0, 0]), tf.bool)
+
+ def subsample(self, indicator, batch_size, labels, scope=None):
+ """Returns subsampled minibatch.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ batch_size: desired batch size. If None, keeps all positive samples and
+ randomly selects negative samples so that the positive sample fraction
+ matches self._positive_fraction. It cannot be None is is_static is True.
+ labels: boolean tensor of shape [N] denoting positive(=True) and negative
+ (=False) examples.
+ scope: name scope.
+
+ Returns:
+ sampled_idx_indicator: boolean tensor of shape [N], True for entries which
+ are sampled.
+
+ Raises:
+ ValueError: if labels and indicator are not 1D boolean tensors.
+ """
+ if len(indicator.get_shape().as_list()) != 1:
+ raise ValueError('indicator must be 1 dimensional, got a tensor of '
+ 'shape %s' % indicator.get_shape())
+ if len(labels.get_shape().as_list()) != 1:
+ raise ValueError('labels must be 1 dimensional, got a tensor of '
+ 'shape %s' % labels.get_shape())
+ if labels.dtype != tf.bool:
+ raise ValueError('labels should be of type bool. Received: %s' %
+ labels.dtype)
+ if indicator.dtype != tf.bool:
+ raise ValueError('indicator should be of type bool. Received: %s' %
+ indicator.dtype)
+ with tf.name_scope(scope, 'BalancedPositiveNegativeSampler'):
+ if self._is_static:
+ return self._static_subsample(indicator, batch_size, labels)
+
+ else:
+ # Only sample from indicated samples
+ negative_idx = tf.logical_not(labels)
+ positive_idx = tf.logical_and(labels, indicator)
+ negative_idx = tf.logical_and(negative_idx, indicator)
+
+ # Sample positive and negative samples separately
+ if batch_size is None:
+ max_num_pos = tf.reduce_sum(tf.cast(positive_idx, dtype=tf.int32))
+ else:
+ max_num_pos = int(self._positive_fraction * batch_size)
+ sampled_pos_idx = self.subsample_indicator(positive_idx, max_num_pos)
+ num_sampled_pos = tf.reduce_sum(tf.cast(sampled_pos_idx, tf.int32))
+ if batch_size is None:
+ negative_positive_ratio = (
+ 1 - self._positive_fraction) / self._positive_fraction
+ max_num_neg = tf.cast(
+ negative_positive_ratio *
+ tf.cast(num_sampled_pos, dtype=tf.float32),
+ dtype=tf.int32)
+ else:
+ max_num_neg = batch_size - num_sampled_pos
+ sampled_neg_idx = self.subsample_indicator(negative_idx, max_num_neg)
+
+ return tf.logical_or(sampled_pos_idx, sampled_neg_idx)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler_test.py
new file mode 100644
index 00000000..788a033d
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/balanced_positive_negative_sampler_test.py
@@ -0,0 +1,203 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.balanced_positive_negative_sampler."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import balanced_positive_negative_sampler
+from object_detection.utils import test_case
+
+
+class BalancedPositiveNegativeSamplerTest(test_case.TestCase):
+
+ def test_subsample_all_examples_dynamic(self):
+ numpy_labels = np.random.permutation(300)
+ indicator = tf.constant(np.ones(300) == 1)
+ numpy_labels = (numpy_labels - 200) > 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 32)
+
+ def test_subsample_all_examples_static(self):
+ numpy_labels = np.random.permutation(300)
+ indicator = np.array(np.ones(300) == 1, np.bool)
+ numpy_labels = (numpy_labels - 200) > 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 32)
+
+ def test_subsample_selection_dynamic(self):
+ # Test random sampling when only some examples can be sampled:
+ # 100 samples, 20 positives, 10 positives cannot be sampled
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 90
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 80) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 54)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_static(self):
+ # Test random sampling when only some examples can be sampled:
+ # 100 samples, 20 positives, 10 positives cannot be sampled.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 90
+ indicator = np.array(numpy_indicator, np.bool)
+ numpy_labels = (numpy_labels - 80) >= 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 54)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
+
+ def test_subsample_selection_larger_batch_size_dynamic(self):
+ # Test random sampling when total number of examples that can be sampled are
+ # less than batch size:
+ # 100 samples, 50 positives, 40 positives cannot be sampled, batch size 64.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 60
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 50) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ is_sampled = sampler.subsample(indicator, 64, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 60)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10)
+ self.assertTrue(
+ sum(np.logical_and(np.logical_not(numpy_labels), is_sampled)) == 50)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_larger_batch_size_static(self):
+ # Test random sampling when total number of examples that can be sampled are
+ # less than batch size:
+ # 100 samples, 50 positives, 40 positives cannot be sampled, batch size 64.
+ # It should still return 64 samples, with 4 of them that couldn't have been
+ # sampled.
+ numpy_labels = np.arange(100)
+ numpy_indicator = numpy_labels < 60
+ indicator = np.array(numpy_indicator, np.bool)
+ numpy_labels = (numpy_labels - 50) >= 0
+
+ labels = np.array(numpy_labels, np.bool)
+
+ def graph_fn(indicator, labels):
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler(
+ is_static=True))
+ return sampler.subsample(indicator, 64, labels)
+
+ is_sampled = self.execute(graph_fn, [indicator, labels])
+ self.assertTrue(sum(is_sampled) == 64)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) >= 10)
+ self.assertTrue(
+ sum(np.logical_and(np.logical_not(numpy_labels), is_sampled)) >= 50)
+ self.assertTrue(sum(np.logical_and(is_sampled, numpy_indicator)) == 60)
+
+ def test_subsample_selection_no_batch_size(self):
+ # Test random sampling when only some examples can be sampled:
+ # 1000 samples, 6 positives (5 can be sampled).
+ numpy_labels = np.arange(1000)
+ numpy_indicator = numpy_labels < 999
+ indicator = tf.constant(numpy_indicator)
+ numpy_labels = (numpy_labels - 994) >= 0
+
+ labels = tf.constant(numpy_labels)
+
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler(0.01))
+ is_sampled = sampler.subsample(indicator, None, labels)
+ with self.test_session() as sess:
+ is_sampled = sess.run(is_sampled)
+ self.assertTrue(sum(is_sampled) == 500)
+ self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 5)
+ self.assertTrue(sum(np.logical_and(
+ np.logical_not(numpy_labels), is_sampled)) == 495)
+ self.assertAllEqual(is_sampled, np.logical_and(is_sampled,
+ numpy_indicator))
+
+ def test_subsample_selection_no_batch_size_static(self):
+ labels = tf.constant([[True, False, False]])
+ indicator = tf.constant([True, False, True])
+ sampler = (
+ balanced_positive_negative_sampler.BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, None, labels)
+
+ def test_raises_error_with_incorrect_label_shape(self):
+ labels = tf.constant([[True, False, False]])
+ indicator = tf.constant([True, False, True])
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, 64, labels)
+
+ def test_raises_error_with_incorrect_indicator_shape(self):
+ labels = tf.constant([True, False, False])
+ indicator = tf.constant([[True, False, True]])
+ sampler = (balanced_positive_negative_sampler.
+ BalancedPositiveNegativeSampler())
+ with self.assertRaises(ValueError):
+ sampler.subsample(indicator, 64, labels)
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batch_multiclass_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batch_multiclass_nms_test.py
new file mode 100644
index 00000000..cd0c56bf
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batch_multiclass_nms_test.py
@@ -0,0 +1,721 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for google3.third_party.tensorflow_models.object_detection.core.batch_multiclass_nms."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from absl.testing import parameterized
+import numpy as np
+from six.moves import range
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.utils import test_case
+
+
+class BatchMulticlassNonMaxSuppressionTest(test_case.TestCase,
+ parameterized.TestCase):
+
+ @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+ def test_batch_multiclass_nms_with_batch_size_1(self, use_static_shapes):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 999, 2, 1004],
+ [0, 100, 1, 101]]]
+ exp_nms_scores = [[.95, .9, .85, .3]]
+ exp_nms_classes = [[0, 0, 1, 0]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields,
+ num_detections) = post_processing.batch_multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class=max_output_size,
+ max_total_size=max_output_size,
+ use_static_shapes=use_static_shapes)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertEqual(num_detections, [4])
+
+ def test_batch_iou_with_negative_data(self):
+ boxes = tf.constant([[[0, -0.01, 0.1, 1.1], [0, 0.2, 0.2, 5.0],
+ [0, -0.01, 0.1, 1.], [-1, -1, -1, -1]]], tf.float32)
+ iou = post_processing.batch_iou(boxes, boxes)
+ expected_iou = [[[0.99999994, 0.0917431, 0.9099099, -1.],
+ [0.0917431, 1., 0.08154944, -1.],
+ [0.9099099, 0.08154944, 1., -1.], [-1., -1., -1., -1.]]]
+ with self.test_session() as sess:
+ iou = sess.run(iou)
+ self.assertAllClose(iou, expected_iou)
+
+ @parameterized.parameters(False, True)
+ def test_batch_multiclass_nms_with_batch_size_2(self, use_dynamic_map_fn):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ use_dynamic_map_fn=use_dynamic_map_fn)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+
+ def test_batch_multiclass_nms_with_per_batch_clip_window(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ clip_window = tf.constant([0., 0., 200., 200.])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.5, .3, 0, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [0, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ clip_window=clip_window)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 2])
+
+ def test_batch_multiclass_nms_with_per_image_clip_window(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ clip_window = tf.constant([[0., 0., 5., 5.],
+ [0., 0., 200., 200.]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.9, 0., 0., 0.],
+ [.5, .3, 0, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [0, 0, 0, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ clip_window=clip_window)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(),
+ exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(),
+ exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(),
+ exp_nms_classes.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [1, 2])
+
+ def test_batch_multiclass_nms_with_masks(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = tf.constant([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]],
+ tf.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_masks = np.array([[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ masks=masks)
+
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(), exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(), exp_nms_classes.shape)
+ self.assertAllEqual(nmsed_masks.shape.as_list(), exp_nms_masks.shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_additional_fields(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ additional_fields = {
+ 'keypoints': tf.constant(
+ [[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]],
+ tf.float32)
+ }
+ additional_fields['size'] = tf.constant(
+ [[[[6], [8]], [[0], [2]], [[0], [0]], [[0], [0]]],
+ [[[13], [15]], [[8], [10]], [[10], [12]], [[0], [0]]]], tf.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_additional_fields = {
+ 'keypoints': np.array([[[[0, 0], [0, 0]],
+ [[6, 7], [8, 9]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[10, 11], [12, 13]],
+ [[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[0, 0], [0, 0]]]])
+ }
+ exp_nms_additional_fields['size'] = np.array([[[[0], [0]], [[6], [8]],
+ [[0], [0]], [[0], [0]]],
+ [[[10], [12]], [[13], [15]],
+ [[8], [10]], [[0], [0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ additional_fields=additional_fields)
+
+ self.assertIsNone(nmsed_masks)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), exp_nms_corners.shape)
+ self.assertAllEqual(nmsed_scores.shape.as_list(), exp_nms_scores.shape)
+ self.assertAllEqual(nmsed_classes.shape.as_list(), exp_nms_classes.shape)
+ self.assertEqual(len(nmsed_additional_fields),
+ len(exp_nms_additional_fields))
+ for key in exp_nms_additional_fields:
+ self.assertAllEqual(nmsed_additional_fields[key].shape.as_list(),
+ exp_nms_additional_fields[key].shape)
+ self.assertEqual(num_detections.shape.as_list(), [2])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_additional_fields,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_additional_fields, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ for key in exp_nms_additional_fields:
+ self.assertAllClose(nmsed_additional_fields[key],
+ exp_nms_additional_fields[key])
+ self.assertAllClose(num_detections, [2, 3])
+
+ def test_batch_multiclass_nms_with_dynamic_batch_size(self):
+ boxes_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2, 4))
+ scores_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2))
+ masks_placeholder = tf.placeholder(tf.float32, shape=(None, None, 2, 2, 2))
+
+ boxes = np.array([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]])
+ scores = np.array([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = np.array([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 999, 2, 1004],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101],
+ [0, 0, 0, 0]]])
+ exp_nms_scores = np.array([[.95, .9, 0, 0],
+ [.85, .5, .3, 0]])
+ exp_nms_classes = np.array([[0, 0, 0, 0],
+ [1, 0, 0, 0]])
+ exp_nms_masks = np.array([[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes_placeholder, scores_placeholder, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ masks=masks_placeholder)
+
+ self.assertIsNone(nmsed_additional_fields)
+ # Check static shapes
+ self.assertAllEqual(nmsed_boxes.shape.as_list(), [None, 4, 4])
+ self.assertAllEqual(nmsed_scores.shape.as_list(), [None, 4])
+ self.assertAllEqual(nmsed_classes.shape.as_list(), [None, 4])
+ self.assertAllEqual(nmsed_masks.shape.as_list(), [None, 4, 2, 2])
+ self.assertEqual(num_detections.shape.as_list(), [None])
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections],
+ feed_dict={boxes_placeholder: boxes,
+ scores_placeholder: scores,
+ masks_placeholder: masks})
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [2, 3])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_masks_and_num_valid_boxes(self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ masks = tf.constant([[[[[0, 1], [2, 3]], [[1, 2], [3, 4]]],
+ [[[2, 3], [4, 5]], [[3, 4], [5, 6]]],
+ [[[4, 5], [6, 7]], [[5, 6], [7, 8]]],
+ [[[6, 7], [8, 9]], [[7, 8], [9, 10]]]],
+ [[[[8, 9], [10, 11]], [[9, 10], [11, 12]]],
+ [[[10, 11], [12, 13]], [[11, 12], [13, 14]]],
+ [[[12, 13], [14, 15]], [[13, 14], [15, 16]]],
+ [[[14, 15], [16, 17]], [[15, 16], [17, 18]]]]],
+ tf.float32)
+ num_valid_boxes = tf.constant([1, 1], tf.int32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_nms_scores = [[.9, 0, 0, 0],
+ [.5, 0, 0, 0]]
+ exp_nms_classes = [[0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_nms_masks = [[[[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[8, 9], [10, 11]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ num_valid_boxes=num_valid_boxes, masks=masks)
+
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_masks, num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertAllClose(num_detections, [1, 1])
+ self.assertAllClose(nmsed_masks, exp_nms_masks)
+
+ def test_batch_multiclass_nms_with_additional_fields_and_num_valid_boxes(
+ self):
+ boxes = tf.constant([[[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]]],
+ [[[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]]],
+ tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0]],
+ [[.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]]])
+ additional_fields = {
+ 'keypoints': tf.constant(
+ [[[[6, 7], [8, 9]],
+ [[0, 1], [2, 3]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[8, 9], [10, 11]],
+ [[10, 11], [12, 13]],
+ [[0, 0], [0, 0]]]],
+ tf.float32)
+ }
+
+ additional_fields['size'] = tf.constant(
+ [[[[7], [9]], [[1], [3]], [[0], [0]], [[0], [0]]],
+ [[[14], [16]], [[9], [11]], [[11], [13]], [[0], [0]]]], tf.float32)
+
+ num_valid_boxes = tf.constant([1, 1], tf.int32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[[0, 0, 1, 1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]],
+ [[0, 10.1, 1, 11.1],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_nms_scores = [[.9, 0, 0, 0],
+ [.5, 0, 0, 0]]
+ exp_nms_classes = [[0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_nms_additional_fields = {
+ 'keypoints': np.array([[[[6, 7], [8, 9]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]],
+ [[[13, 14], [15, 16]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]],
+ [[0, 0], [0, 0]]]])
+ }
+
+ exp_nms_additional_fields['size'] = np.array([[[[7], [9]], [[0], [0]],
+ [[0], [0]], [[0], [0]]],
+ [[[14], [16]], [[0], [0]],
+ [[0], [0]], [[0], [0]]]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ num_valid_boxes=num_valid_boxes,
+ additional_fields=additional_fields)
+
+ self.assertIsNone(nmsed_masks)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_additional_fields,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ nmsed_additional_fields, num_detections])
+
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ for key in exp_nms_additional_fields:
+ self.assertAllClose(nmsed_additional_fields[key],
+ exp_nms_additional_fields[key])
+ self.assertAllClose(num_detections, [1, 1])
+
+ def test_combined_nms_with_batch_size_2(self):
+ """Test use_combined_nms."""
+ boxes = tf.constant([[[[0, 0, 0.1, 0.1], [0, 0, 0.1, 0.1]],
+ [[0, 0.01, 1, 0.11], [0, 0.6, 0.1, 0.7]],
+ [[0, -0.01, 0.1, 0.09], [0, -0.1, 0.1, 0.09]],
+ [[0, 0.11, 0.1, 0.2], [0, 0.11, 0.1, 0.2]]],
+ [[[0, 0, 0.2, 0.2], [0, 0, 0.2, 0.2]],
+ [[0, 0.02, 0.2, 0.22], [0, 0.02, 0.2, 0.22]],
+ [[0, -0.02, 0.2, 0.19], [0, -0.02, 0.2, 0.19]],
+ [[0, 0.21, 0.2, 0.3], [0, 0.21, 0.2, 0.3]]]],
+ tf.float32)
+ scores = tf.constant([[[.1, 0.9], [.75, 0.8],
+ [.6, 0.3], [0.95, 0.1]],
+ [[.1, 0.9], [.75, 0.8],
+ [.6, .3], [.95, .1]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms_corners = np.array([[[0, 0.11, 0.1, 0.2],
+ [0, 0, 0.1, 0.1],
+ [0, 0.6, 0.1, 0.7]],
+ [[0, 0.21, 0.2, 0.3],
+ [0, 0, 0.2, 0.2],
+ [0, 0.02, 0.2, 0.22]]])
+ exp_nms_scores = np.array([[.95, .9, 0.8],
+ [.95, .9, .75]])
+ exp_nms_classes = np.array([[0, 1, 1],
+ [0, 1, 0]])
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields, num_detections
+ ) = post_processing.batch_multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh,
+ max_size_per_class=max_output_size, max_total_size=max_output_size,
+ use_static_shapes=True,
+ use_combined_nms=True)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections) = sess.run([nmsed_boxes, nmsed_scores, nmsed_classes,
+ num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertListEqual(num_detections.tolist(), [3, 3])
+
+ # TODO(bhattad): Remove conditional after CMLE moves to TF 1.9
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher.py
new file mode 100644
index 00000000..825b90d8
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher.py
@@ -0,0 +1,141 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Provides functions to batch a dictionary of input tensors."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import prefetcher
+
+rt_shape_str = '_runtime_shapes'
+
+
+class BatchQueue(object):
+ """BatchQueue class.
+
+ This class creates a batch queue to asynchronously enqueue tensors_dict.
+ It also adds a FIFO prefetcher so that the batches are readily available
+ for the consumers. Dequeue ops for a BatchQueue object can be created via
+ the Dequeue method which evaluates to a batch of tensor_dict.
+
+ Example input pipeline with batching:
+ ------------------------------------
+ key, string_tensor = slim.parallel_reader.parallel_read(...)
+ tensor_dict = decoder.decode(string_tensor)
+ tensor_dict = preprocessor.preprocess(tensor_dict, ...)
+ batch_queue = batcher.BatchQueue(tensor_dict,
+ batch_size=32,
+ batch_queue_capacity=2000,
+ num_batch_queue_threads=8,
+ prefetch_queue_capacity=20)
+ tensor_dict = batch_queue.dequeue()
+ outputs = Model(tensor_dict)
+ ...
+ -----------------------------------
+
+ Notes:
+ -----
+ This class batches tensors of unequal sizes by zero padding and unpadding
+ them after generating a batch. This can be computationally expensive when
+ batching tensors (such as images) that are of vastly different sizes. So it is
+ recommended that the shapes of such tensors be fully defined in tensor_dict
+ while other lightweight tensors such as bounding box corners and class labels
+ can be of varying sizes. Use either crop or resize operations to fully define
+ the shape of an image in tensor_dict.
+
+ It is also recommended to perform any preprocessing operations on tensors
+ before passing to BatchQueue and subsequently calling the Dequeue method.
+
+ Another caveat is that this class does not read the last batch if it is not
+ full. The current implementation makes it hard to support that use case. So,
+ for evaluation, when it is critical to run all the examples through your
+ network use the input pipeline example mentioned in core/prefetcher.py.
+ """
+
+ def __init__(self, tensor_dict, batch_size, batch_queue_capacity,
+ num_batch_queue_threads, prefetch_queue_capacity):
+ """Constructs a batch queue holding tensor_dict.
+
+ Args:
+ tensor_dict: dictionary of tensors to batch.
+ batch_size: batch size.
+ batch_queue_capacity: max capacity of the queue from which the tensors are
+ batched.
+ num_batch_queue_threads: number of threads to use for batching.
+ prefetch_queue_capacity: max capacity of the queue used to prefetch
+ assembled batches.
+ """
+ # Remember static shapes to set shapes of batched tensors.
+ static_shapes = collections.OrderedDict(
+ {key: tensor.get_shape() for key, tensor in tensor_dict.items()})
+ # Remember runtime shapes to unpad tensors after batching.
+ runtime_shapes = collections.OrderedDict(
+ {(key + rt_shape_str): tf.shape(tensor)
+ for key, tensor in tensor_dict.items()})
+
+ all_tensors = tensor_dict
+ all_tensors.update(runtime_shapes)
+ batched_tensors = tf.train.batch(
+ all_tensors,
+ capacity=batch_queue_capacity,
+ batch_size=batch_size,
+ dynamic_pad=True,
+ num_threads=num_batch_queue_threads)
+
+ self._queue = prefetcher.prefetch(batched_tensors,
+ prefetch_queue_capacity)
+ self._static_shapes = static_shapes
+ self._batch_size = batch_size
+
+ def dequeue(self):
+ """Dequeues a batch of tensor_dict from the BatchQueue.
+
+ TODO: use allow_smaller_final_batch to allow running over the whole eval set
+
+ Returns:
+ A list of tensor_dicts of the requested batch_size.
+ """
+ batched_tensors = self._queue.dequeue()
+ # Separate input tensors from tensors containing their runtime shapes.
+ tensors = {}
+ shapes = {}
+ for key, batched_tensor in batched_tensors.items():
+ unbatched_tensor_list = tf.unstack(batched_tensor)
+ for i, unbatched_tensor in enumerate(unbatched_tensor_list):
+ if rt_shape_str in key:
+ shapes[(key[:-len(rt_shape_str)], i)] = unbatched_tensor
+ else:
+ tensors[(key, i)] = unbatched_tensor
+
+ # Undo that padding using shapes and create a list of size `batch_size` that
+ # contains tensor dictionaries.
+ tensor_dict_list = []
+ batch_size = self._batch_size
+ for batch_id in range(batch_size):
+ tensor_dict = {}
+ for key in self._static_shapes:
+ tensor_dict[key] = tf.slice(tensors[(key, batch_id)],
+ tf.zeros_like(shapes[(key, batch_id)]),
+ shapes[(key, batch_id)])
+ tensor_dict[key].set_shape(self._static_shapes[key])
+ tensor_dict_list.append(tensor_dict)
+
+ return tensor_dict_list
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher_test.py
new file mode 100644
index 00000000..a6c9faf2
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/batcher_test.py
@@ -0,0 +1,163 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.batcher."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import batcher
+
+slim = tf.contrib.slim
+
+
+class BatcherTest(tf.test.TestCase):
+
+ def test_batch_and_unpad_2d_tensors_of_different_sizes_in_1st_dimension(self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ boxes = tf.tile(
+ tf.reshape(tf.range(4), [1, 4]), tf.stack([counter, tf.constant(1)]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'boxes': boxes},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, 4], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.tile(np.arange(4), (i, 1)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batch_and_unpad_2d_tensors_of_different_sizes_in_all_dimensions(
+ self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ image = tf.reshape(
+ tf.range(counter * counter), tf.stack([counter, counter]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, None], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(i * i).reshape((i, i)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batch_and_unpad_2d_tensors_of_same_size_in_all_dimensions(self):
+ with self.test_session() as sess:
+ batch_size = 3
+ num_batches = 2
+ examples = tf.Variable(tf.constant(1, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 1)
+ image = tf.reshape(tf.range(1, 13), [4, 3]) * counter
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([4, 3], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 1
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(1, 13).reshape((4, 3)) * i)
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+ def test_batcher_when_batch_size_is_one(self):
+ with self.test_session() as sess:
+ batch_size = 1
+ num_batches = 2
+ examples = tf.Variable(tf.constant(2, dtype=tf.int32))
+ counter = examples.count_up_to(num_batches * batch_size + 2)
+ image = tf.reshape(
+ tf.range(counter * counter), tf.stack([counter, counter]))
+ batch_queue = batcher.BatchQueue(
+ tensor_dict={'image': image},
+ batch_size=batch_size,
+ batch_queue_capacity=100,
+ num_batch_queue_threads=1,
+ prefetch_queue_capacity=100)
+ batch = batch_queue.dequeue()
+
+ for tensor_dict in batch:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual([None, None], tensor.get_shape().as_list())
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ i = 2
+ for _ in range(num_batches):
+ batch_np = sess.run(batch)
+ for tensor_dict in batch_np:
+ for tensor in tensor_dict.values():
+ self.assertAllEqual(tensor, np.arange(i * i).reshape((i, i)))
+ i += 1
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(batch)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder.py
new file mode 100644
index 00000000..82f084d6
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder.py
@@ -0,0 +1,158 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base box coder.
+
+Box coders convert between coordinate frames, namely image-centric
+(with (0,0) on the top left of image) and anchor-centric (with (0,0) being
+defined by a specific anchor).
+
+Users of a BoxCoder can call two methods:
+ encode: which encodes a box with respect to a given anchor
+ (or rather, a tensor of boxes wrt a corresponding tensor of anchors) and
+ decode: which inverts this encoding with a decode operation.
+In both cases, the arguments are assumed to be in 1-1 correspondence already;
+it is not the job of a BoxCoder to perform matching.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+from abc import abstractproperty
+
+import six
+import tensorflow as tf
+
+from object_detection.utils import shape_utils
+
+
+# Box coder types.
+FASTER_RCNN = 'faster_rcnn'
+KEYPOINT = 'keypoint'
+MEAN_STDDEV = 'mean_stddev'
+SQUARE = 'square'
+
+
+class BoxCoder(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for box coder."""
+
+ @abstractproperty
+ def code_size(self):
+ """Return the size of each code.
+
+ This number is a constant and should agree with the output of the `encode`
+ op (e.g. if rel_codes is the output of self.encode(...), then it should have
+ shape [N, code_size()]). This abstractproperty should be overridden by
+ implementations.
+
+ Returns:
+ an integer constant
+ """
+ pass
+
+ def encode(self, boxes, anchors):
+ """Encode a box list relative to an anchor collection.
+
+ Args:
+ boxes: BoxList holding N boxes to be encoded
+ anchors: BoxList of N anchors
+
+ Returns:
+ a tensor representing N relative-encoded boxes
+ """
+ with tf.name_scope('Encode'):
+ return self._encode(boxes, anchors)
+
+ def decode(self, rel_codes, anchors):
+ """Decode boxes that are encoded relative to an anchor collection.
+
+ Args:
+ rel_codes: a tensor representing N relative-encoded boxes
+ anchors: BoxList of anchors
+
+ Returns:
+ boxlist: BoxList holding N boxes encoded in the ordinary way (i.e.,
+ with corners y_min, x_min, y_max, x_max)
+ """
+ with tf.name_scope('Decode'):
+ return self._decode(rel_codes, anchors)
+
+ @abstractmethod
+ def _encode(self, boxes, anchors):
+ """Method to be overriden by implementations.
+
+ Args:
+ boxes: BoxList holding N boxes to be encoded
+ anchors: BoxList of N anchors
+
+ Returns:
+ a tensor representing N relative-encoded boxes
+ """
+ pass
+
+ @abstractmethod
+ def _decode(self, rel_codes, anchors):
+ """Method to be overriden by implementations.
+
+ Args:
+ rel_codes: a tensor representing N relative-encoded boxes
+ anchors: BoxList of anchors
+
+ Returns:
+ boxlist: BoxList holding N boxes encoded in the ordinary way (i.e.,
+ with corners y_min, x_min, y_max, x_max)
+ """
+ pass
+
+
+def batch_decode(encoded_boxes, box_coder, anchors):
+ """Decode a batch of encoded boxes.
+
+ This op takes a batch of encoded bounding boxes and transforms
+ them to a batch of bounding boxes specified by their corners in
+ the order of [y_min, x_min, y_max, x_max].
+
+ Args:
+ encoded_boxes: a float32 tensor of shape [batch_size, num_anchors,
+ code_size] representing the location of the objects.
+ box_coder: a BoxCoder object.
+ anchors: a BoxList of anchors used to encode `encoded_boxes`.
+
+ Returns:
+ decoded_boxes: a float32 tensor of shape [batch_size, num_anchors,
+ coder_size] representing the corners of the objects in the order
+ of [y_min, x_min, y_max, x_max].
+
+ Raises:
+ ValueError: if batch sizes of the inputs are inconsistent, or if
+ the number of anchors inferred from encoded_boxes and anchors are
+ inconsistent.
+ """
+ encoded_boxes.get_shape().assert_has_rank(3)
+ if (shape_utils.get_dim_as_int(encoded_boxes.get_shape()[1])
+ != anchors.num_boxes_static()):
+ raise ValueError('The number of anchors inferred from encoded_boxes'
+ ' and anchors are inconsistent: shape[1] of encoded_boxes'
+ ' %s should be equal to the number of anchors: %s.' %
+ (shape_utils.get_dim_as_int(encoded_boxes.get_shape()[1]),
+ anchors.num_boxes_static()))
+
+ decoded_boxes = tf.stack([
+ box_coder.decode(boxes, anchors).get()
+ for boxes in tf.unstack(encoded_boxes)
+ ])
+ return decoded_boxes
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder_test.py
new file mode 100644
index 00000000..c087a325
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_coder_test.py
@@ -0,0 +1,61 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_coder."""
+
+import tensorflow as tf
+
+from object_detection.core import box_coder
+from object_detection.core import box_list
+
+
+class MockBoxCoder(box_coder.BoxCoder):
+ """Test BoxCoder that encodes/decodes using the multiply-by-two function."""
+
+ def code_size(self):
+ return 4
+
+ def _encode(self, boxes, anchors):
+ return 2.0 * boxes.get()
+
+ def _decode(self, rel_codes, anchors):
+ return box_list.BoxList(rel_codes / 2.0)
+
+
+class BoxCoderTest(tf.test.TestCase):
+
+ def test_batch_decode(self):
+ mock_anchor_corners = tf.constant(
+ [[0, 0.1, 0.2, 0.3], [0.2, 0.4, 0.4, 0.6]], tf.float32)
+ mock_anchors = box_list.BoxList(mock_anchor_corners)
+ mock_box_coder = MockBoxCoder()
+
+ expected_boxes = [[[0.0, 0.1, 0.5, 0.6], [0.5, 0.6, 0.7, 0.8]],
+ [[0.1, 0.2, 0.3, 0.4], [0.7, 0.8, 0.9, 1.0]]]
+
+ encoded_boxes_list = [mock_box_coder.encode(
+ box_list.BoxList(tf.constant(boxes)), mock_anchors)
+ for boxes in expected_boxes]
+ encoded_boxes = tf.stack(encoded_boxes_list)
+ decoded_boxes = box_coder.batch_decode(
+ encoded_boxes, mock_box_coder, mock_anchors)
+
+ with self.test_session() as sess:
+ decoded_boxes_result = sess.run(decoded_boxes)
+ self.assertAllClose(expected_boxes, decoded_boxes_result)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list.py
new file mode 100644
index 00000000..cda75755
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list.py
@@ -0,0 +1,210 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Bounding Box List definition.
+
+BoxList represents a list of bounding boxes as tensorflow
+tensors, where each bounding box is represented as a row of 4 numbers,
+[y_min, x_min, y_max, x_max]. It is assumed that all bounding boxes
+within a given list correspond to a single image. See also
+box_list_ops.py for common box related operations (such as area, iou, etc).
+
+Optionally, users can add additional related fields (such as weights).
+We assume the following things to be true about fields:
+* they correspond to boxes in the box_list along the 0th dimension
+* they have inferrable rank at graph construction time
+* all dimensions except for possibly the 0th can be inferred
+ (i.e., not None) at graph construction time.
+
+Some other notes:
+ * Following tensorflow conventions, we use height, width ordering,
+ and correspondingly, y,x (or ymin, xmin, ymax, xmax) ordering
+ * Tensors are always provided as (flat) [N, 4] tensors.
+"""
+
+import tensorflow as tf
+
+from object_detection.utils import shape_utils
+
+
+class BoxList(object):
+ """Box collection."""
+
+ def __init__(self, boxes):
+ """Constructs box collection.
+
+ Args:
+ boxes: a tensor of shape [N, 4] representing box corners
+
+ Raises:
+ ValueError: if invalid dimensions for bbox data or if bbox data is not in
+ float32 format.
+ """
+ if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
+ raise ValueError('Invalid dimensions for box data: {}'.format(
+ boxes.shape))
+ if boxes.dtype != tf.float32:
+ raise ValueError('Invalid tensor type: should be tf.float32')
+ self.data = {'boxes': boxes}
+
+ def num_boxes(self):
+ """Returns number of boxes held in collection.
+
+ Returns:
+ a tensor representing the number of boxes held in the collection.
+ """
+ return tf.shape(self.data['boxes'])[0]
+
+ def num_boxes_static(self):
+ """Returns number of boxes held in collection.
+
+ This number is inferred at graph construction time rather than run-time.
+
+ Returns:
+ Number of boxes held in collection (integer) or None if this is not
+ inferrable at graph construction time.
+ """
+ return shape_utils.get_dim_as_int(self.data['boxes'].get_shape()[0])
+
+ def get_all_fields(self):
+ """Returns all fields."""
+ return self.data.keys()
+
+ def get_extra_fields(self):
+ """Returns all non-box fields (i.e., everything not named 'boxes')."""
+ return [k for k in self.data.keys() if k != 'boxes']
+
+ def add_field(self, field, field_data):
+ """Add field to box list.
+
+ This method can be used to add related box data such as
+ weights/labels, etc.
+
+ Args:
+ field: a string key to access the data via `get`
+ field_data: a tensor containing the data to store in the BoxList
+ """
+ self.data[field] = field_data
+
+ def has_field(self, field):
+ return field in self.data
+
+ def get(self):
+ """Convenience function for accessing box coordinates.
+
+ Returns:
+ a tensor with shape [N, 4] representing box coordinates.
+ """
+ return self.get_field('boxes')
+
+ def set(self, boxes):
+ """Convenience function for setting box coordinates.
+
+ Args:
+ boxes: a tensor of shape [N, 4] representing box corners
+
+ Raises:
+ ValueError: if invalid dimensions for bbox data
+ """
+ if len(boxes.get_shape()) != 2 or boxes.get_shape()[-1] != 4:
+ raise ValueError('Invalid dimensions for box data.')
+ self.data['boxes'] = boxes
+
+ def get_field(self, field):
+ """Accesses a box collection and associated fields.
+
+ This function returns specified field with object; if no field is specified,
+ it returns the box coordinates.
+
+ Args:
+ field: this optional string parameter can be used to specify
+ a related field to be accessed.
+
+ Returns:
+ a tensor representing the box collection or an associated field.
+
+ Raises:
+ ValueError: if invalid field
+ """
+ if not self.has_field(field):
+ raise ValueError('field ' + str(field) + ' does not exist')
+ return self.data[field]
+
+ def set_field(self, field, value):
+ """Sets the value of a field.
+
+ Updates the field of a box_list with a given value.
+
+ Args:
+ field: (string) name of the field to set value.
+ value: the value to assign to the field.
+
+ Raises:
+ ValueError: if the box_list does not have specified field.
+ """
+ if not self.has_field(field):
+ raise ValueError('field %s does not exist' % field)
+ self.data[field] = value
+
+ def get_center_coordinates_and_sizes(self, scope=None):
+ """Computes the center coordinates, height and width of the boxes.
+
+ Args:
+ scope: name scope of the function.
+
+ Returns:
+ a list of 4 1-D tensors [ycenter, xcenter, height, width].
+ """
+ with tf.name_scope(scope, 'get_center_coordinates_and_sizes'):
+ box_corners = self.get()
+ ymin, xmin, ymax, xmax = tf.unstack(tf.transpose(box_corners))
+ width = xmax - xmin
+ height = ymax - ymin
+ ycenter = ymin + height / 2.
+ xcenter = xmin + width / 2.
+ return [ycenter, xcenter, height, width]
+
+ def transpose_coordinates(self, scope=None):
+ """Transpose the coordinate representation in a boxlist.
+
+ Args:
+ scope: name scope of the function.
+ """
+ with tf.name_scope(scope, 'transpose_coordinates'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=self.get(), num_or_size_splits=4, axis=1)
+ self.set(tf.concat([x_min, y_min, x_max, y_max], 1))
+
+ def as_tensor_dict(self, fields=None):
+ """Retrieves specified fields as a dictionary of tensors.
+
+ Args:
+ fields: (optional) list of fields to return in the dictionary.
+ If None (default), all fields are returned.
+
+ Returns:
+ tensor_dict: A dictionary of tensors specified by fields.
+
+ Raises:
+ ValueError: if specified field is not contained in boxlist.
+ """
+ tensor_dict = {}
+ if fields is None:
+ fields = self.get_all_fields()
+ for field in fields:
+ if not self.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ tensor_dict[field] = self.get_field(field)
+ return tensor_dict
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops.py
new file mode 100644
index 00000000..0bd3788f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops.py
@@ -0,0 +1,1141 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Bounding Box List operations.
+
+Example box operations that are supported:
+ * areas: compute bounding box areas
+ * iou: pairwise intersection-over-union scores
+ * sq_dist: pairwise distances between bounding boxes
+
+Whenever box_list_ops functions output a BoxList, the fields of the incoming
+BoxList are retained unless documented otherwise.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.utils import ops
+from object_detection.utils import shape_utils
+
+
+class SortOrder(object):
+ """Enum class for sort order.
+
+ Attributes:
+ ascend: ascend order.
+ descend: descend order.
+ """
+ ascend = 1
+ descend = 2
+
+
+def area(boxlist, scope=None):
+ """Computes area of boxes.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing box areas.
+ """
+ with tf.name_scope(scope, 'Area'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ return tf.squeeze((y_max - y_min) * (x_max - x_min), [1])
+
+
+def height_width(boxlist, scope=None):
+ """Computes height and width of boxes in boxlist.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ Height: A tensor with shape [N] representing box heights.
+ Width: A tensor with shape [N] representing box widths.
+ """
+ with tf.name_scope(scope, 'HeightWidth'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ return tf.squeeze(y_max - y_min, [1]), tf.squeeze(x_max - x_min, [1])
+
+
+def scale(boxlist, y_scale, x_scale, scope=None):
+ """scale box coordinates in x and y dimensions.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ y_scale: (float) scalar tensor
+ x_scale: (float) scalar tensor
+ scope: name scope.
+
+ Returns:
+ boxlist: BoxList holding N boxes
+ """
+ with tf.name_scope(scope, 'Scale'):
+ y_scale = tf.cast(y_scale, tf.float32)
+ x_scale = tf.cast(x_scale, tf.float32)
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ y_min = y_scale * y_min
+ y_max = y_scale * y_max
+ x_min = x_scale * x_min
+ x_max = x_scale * x_max
+ scaled_boxlist = box_list.BoxList(
+ tf.concat([y_min, x_min, y_max, x_max], 1))
+ return _copy_extra_fields(scaled_boxlist, boxlist)
+
+
+def clip_to_window(boxlist, window, filter_nonoverlapping=True, scope=None):
+ """Clip bounding boxes to a window.
+
+ This op clips any input bounding boxes (represented by bounding box
+ corners) to a window, optionally filtering out boxes that do not
+ overlap at all with the window.
+
+ Args:
+ boxlist: BoxList holding M_in boxes
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window to which the op should clip boxes.
+ filter_nonoverlapping: whether to filter out boxes that do not overlap at
+ all with the window.
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M_out boxes where M_out <= M_in
+ """
+ with tf.name_scope(scope, 'ClipToWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ y_min_clipped = tf.maximum(tf.minimum(y_min, win_y_max), win_y_min)
+ y_max_clipped = tf.maximum(tf.minimum(y_max, win_y_max), win_y_min)
+ x_min_clipped = tf.maximum(tf.minimum(x_min, win_x_max), win_x_min)
+ x_max_clipped = tf.maximum(tf.minimum(x_max, win_x_max), win_x_min)
+ clipped = box_list.BoxList(
+ tf.concat([y_min_clipped, x_min_clipped, y_max_clipped, x_max_clipped],
+ 1))
+ clipped = _copy_extra_fields(clipped, boxlist)
+ if filter_nonoverlapping:
+ areas = area(clipped)
+ nonzero_area_indices = tf.cast(
+ tf.reshape(tf.where(tf.greater(areas, 0.0)), [-1]), tf.int32)
+ clipped = gather(clipped, nonzero_area_indices)
+ return clipped
+
+
+def prune_outside_window(boxlist, window, scope=None):
+ """Prunes bounding boxes that fall outside a given window.
+
+ This function prunes bounding boxes that even partially fall outside the given
+ window. See also clip_to_window which only prunes bounding boxes that fall
+ completely outside the window, and clips any bounding boxes that partially
+ overflow.
+
+ Args:
+ boxlist: a BoxList holding M_in boxes.
+ window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax]
+ of the window
+ scope: name scope.
+
+ Returns:
+ pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in
+ valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
+ in the input tensor.
+ """
+ with tf.name_scope(scope, 'PruneOutsideWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ coordinate_violations = tf.concat([
+ tf.less(y_min, win_y_min), tf.less(x_min, win_x_min),
+ tf.greater(y_max, win_y_max), tf.greater(x_max, win_x_max)
+ ], 1)
+ valid_indices = tf.reshape(
+ tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1])
+ return gather(boxlist, valid_indices), valid_indices
+
+
+def prune_completely_outside_window(boxlist, window, scope=None):
+ """Prunes bounding boxes that fall completely outside of the given window.
+
+ The function clip_to_window prunes bounding boxes that fall
+ completely outside the window, but also clips any bounding boxes that
+ partially overflow. This function does not clip partially overflowing boxes.
+
+ Args:
+ boxlist: a BoxList holding M_in boxes.
+ window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax]
+ of the window
+ scope: name scope.
+
+ Returns:
+ pruned_boxlist: a new BoxList with all bounding boxes partially or fully in
+ the window.
+ valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes
+ in the input tensor.
+ """
+ with tf.name_scope(scope, 'PruneCompleteleyOutsideWindow'):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=boxlist.get(), num_or_size_splits=4, axis=1)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ coordinate_violations = tf.concat([
+ tf.greater_equal(y_min, win_y_max), tf.greater_equal(x_min, win_x_max),
+ tf.less_equal(y_max, win_y_min), tf.less_equal(x_max, win_x_min)
+ ], 1)
+ valid_indices = tf.reshape(
+ tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1])
+ return gather(boxlist, valid_indices), valid_indices
+
+
+def intersection(boxlist1, boxlist2, scope=None):
+ """Compute pairwise intersection areas between boxes.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise intersections
+ """
+ with tf.name_scope(scope, 'Intersection'):
+ y_min1, x_min1, y_max1, x_max1 = tf.split(
+ value=boxlist1.get(), num_or_size_splits=4, axis=1)
+ y_min2, x_min2, y_max2, x_max2 = tf.split(
+ value=boxlist2.get(), num_or_size_splits=4, axis=1)
+ all_pairs_min_ymax = tf.minimum(y_max1, tf.transpose(y_max2))
+ all_pairs_max_ymin = tf.maximum(y_min1, tf.transpose(y_min2))
+ intersect_heights = tf.maximum(0.0, all_pairs_min_ymax - all_pairs_max_ymin)
+ all_pairs_min_xmax = tf.minimum(x_max1, tf.transpose(x_max2))
+ all_pairs_max_xmin = tf.maximum(x_min1, tf.transpose(x_min2))
+ intersect_widths = tf.maximum(0.0, all_pairs_min_xmax - all_pairs_max_xmin)
+ return intersect_heights * intersect_widths
+
+
+def matched_intersection(boxlist1, boxlist2, scope=None):
+ """Compute intersection areas between corresponding boxes in two boxlists.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing pairwise intersections
+ """
+ with tf.name_scope(scope, 'MatchedIntersection'):
+ y_min1, x_min1, y_max1, x_max1 = tf.split(
+ value=boxlist1.get(), num_or_size_splits=4, axis=1)
+ y_min2, x_min2, y_max2, x_max2 = tf.split(
+ value=boxlist2.get(), num_or_size_splits=4, axis=1)
+ min_ymax = tf.minimum(y_max1, y_max2)
+ max_ymin = tf.maximum(y_min1, y_min2)
+ intersect_heights = tf.maximum(0.0, min_ymax - max_ymin)
+ min_xmax = tf.minimum(x_max1, x_max2)
+ max_xmin = tf.maximum(x_min1, x_min2)
+ intersect_widths = tf.maximum(0.0, min_xmax - max_xmin)
+ return tf.reshape(intersect_heights * intersect_widths, [-1])
+
+
+def iou(boxlist1, boxlist2, scope=None):
+ """Computes pairwise intersection-over-union between box collections.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise iou scores.
+ """
+ with tf.name_scope(scope, 'IOU'):
+ intersections = intersection(boxlist1, boxlist2)
+ areas1 = area(boxlist1)
+ areas2 = area(boxlist2)
+ unions = (
+ tf.expand_dims(areas1, 1) + tf.expand_dims(areas2, 0) - intersections)
+ return tf.where(
+ tf.equal(intersections, 0.0),
+ tf.zeros_like(intersections), tf.truediv(intersections, unions))
+
+
+def matched_iou(boxlist1, boxlist2, scope=None):
+ """Compute intersection-over-union between corresponding boxes in boxlists.
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding N boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N] representing pairwise iou scores.
+ """
+ with tf.name_scope(scope, 'MatchedIOU'):
+ intersections = matched_intersection(boxlist1, boxlist2)
+ areas1 = area(boxlist1)
+ areas2 = area(boxlist2)
+ unions = areas1 + areas2 - intersections
+ return tf.where(
+ tf.equal(intersections, 0.0),
+ tf.zeros_like(intersections), tf.truediv(intersections, unions))
+
+
+def ioa(boxlist1, boxlist2, scope=None):
+ """Computes pairwise intersection-over-area between box collections.
+
+ intersection-over-area (IOA) between two boxes box1 and box2 is defined as
+ their intersection area over box2's area. Note that ioa is not symmetric,
+ that is, ioa(box1, box2) != ioa(box2, box1).
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise ioa scores.
+ """
+ with tf.name_scope(scope, 'IOA'):
+ intersections = intersection(boxlist1, boxlist2)
+ areas = tf.expand_dims(area(boxlist2), 0)
+ return tf.truediv(intersections, areas)
+
+
+def prune_non_overlapping_boxes(
+ boxlist1, boxlist2, min_overlap=0.0, scope=None):
+ """Prunes the boxes in boxlist1 that overlap less than thresh with boxlist2.
+
+ For each box in boxlist1, we want its IOA to be more than minoverlap with
+ at least one of the boxes in boxlist2. If it does not, we remove it.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+ min_overlap: Minimum required overlap between boxes, to count them as
+ overlapping.
+ scope: name scope.
+
+ Returns:
+ new_boxlist1: A pruned boxlist with size [N', 4].
+ keep_inds: A tensor with shape [N'] indexing kept bounding boxes in the
+ first input BoxList `boxlist1`.
+ """
+ with tf.name_scope(scope, 'PruneNonOverlappingBoxes'):
+ ioa_ = ioa(boxlist2, boxlist1) # [M, N] tensor
+ ioa_ = tf.reduce_max(ioa_, reduction_indices=[0]) # [N] tensor
+ keep_bool = tf.greater_equal(ioa_, tf.constant(min_overlap))
+ keep_inds = tf.squeeze(tf.where(keep_bool), axis=[1])
+ new_boxlist1 = gather(boxlist1, keep_inds)
+ return new_boxlist1, keep_inds
+
+
+def prune_small_boxes(boxlist, min_side, scope=None):
+ """Prunes small boxes in the boxlist which have a side smaller than min_side.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ min_side: Minimum width AND height of box to survive pruning.
+ scope: name scope.
+
+ Returns:
+ A pruned boxlist.
+ """
+ with tf.name_scope(scope, 'PruneSmallBoxes'):
+ height, width = height_width(boxlist)
+ is_valid = tf.logical_and(tf.greater_equal(width, min_side),
+ tf.greater_equal(height, min_side))
+ return gather(boxlist, tf.reshape(tf.where(is_valid), [-1]))
+
+
+def change_coordinate_frame(boxlist, window, scope=None):
+ """Change coordinate frame of the boxlist to be relative to window's frame.
+
+ Given a window of the form [ymin, xmin, ymax, xmax],
+ changes bounding box coordinates from boxlist to be relative to this window
+ (e.g., the min corner maps to (0,0) and the max corner maps to (1,1)).
+
+ An example use case is data augmentation: where we are given groundtruth
+ boxes (boxlist) and would like to randomly crop the image to some
+ window (window). In this case we need to change the coordinate frame of
+ each groundtruth box to be relative to this new window.
+
+ Args:
+ boxlist: A BoxList object holding N boxes.
+ window: A rank 1 tensor [4].
+ scope: name scope.
+
+ Returns:
+ Returns a BoxList object with N boxes.
+ """
+ with tf.name_scope(scope, 'ChangeCoordinateFrame'):
+ win_height = window[2] - window[0]
+ win_width = window[3] - window[1]
+ boxlist_new = scale(box_list.BoxList(
+ boxlist.get() - [window[0], window[1], window[0], window[1]]),
+ 1.0 / win_height, 1.0 / win_width)
+ boxlist_new = _copy_extra_fields(boxlist_new, boxlist)
+ return boxlist_new
+
+
+def sq_dist(boxlist1, boxlist2, scope=None):
+ """Computes the pairwise squared distances between box corners.
+
+ This op treats each box as if it were a point in a 4d Euclidean space and
+ computes pairwise squared distances.
+
+ Mathematically, we are given two matrices of box coordinates X and Y,
+ where X(i,:) is the i'th row of X, containing the 4 numbers defining the
+ corners of the i'th box in boxlist1. Similarly Y(j,:) corresponds to
+ boxlist2. We compute
+ Z(i,j) = ||X(i,:) - Y(j,:)||^2
+ = ||X(i,:)||^2 + ||Y(j,:)||^2 - 2 X(i,:)' * Y(j,:),
+
+ Args:
+ boxlist1: BoxList holding N boxes
+ boxlist2: BoxList holding M boxes
+ scope: name scope.
+
+ Returns:
+ a tensor with shape [N, M] representing pairwise distances
+ """
+ with tf.name_scope(scope, 'SqDist'):
+ sqnorm1 = tf.reduce_sum(tf.square(boxlist1.get()), 1, keep_dims=True)
+ sqnorm2 = tf.reduce_sum(tf.square(boxlist2.get()), 1, keep_dims=True)
+ innerprod = tf.matmul(boxlist1.get(), boxlist2.get(),
+ transpose_a=False, transpose_b=True)
+ return sqnorm1 + tf.transpose(sqnorm2) - 2.0 * innerprod
+
+
+def boolean_mask(boxlist, indicator, fields=None, scope=None,
+ use_static_shapes=False, indicator_sum=None):
+ """Select boxes from BoxList according to indicator and return new BoxList.
+
+ `boolean_mask` returns the subset of boxes that are marked as "True" by the
+ indicator tensor. By default, `boolean_mask` returns boxes corresponding to
+ the input index list, as well as all additional fields stored in the boxlist
+ (indexing into the first dimension). However one can optionally only draw
+ from a subset of fields.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ indicator: a rank-1 boolean tensor
+ fields: (optional) list of fields to also gather from. If None (default),
+ all fields are gathered from. Pass an empty fields list to only gather
+ the box coordinates.
+ scope: name scope.
+ use_static_shapes: Whether to use an implementation with static shape
+ gurantees.
+ indicator_sum: An integer containing the sum of `indicator` vector. Only
+ required if `use_static_shape` is True.
+
+ Returns:
+ subboxlist: a BoxList corresponding to the subset of the input BoxList
+ specified by indicator
+ Raises:
+ ValueError: if `indicator` is not a rank-1 boolean tensor.
+ """
+ with tf.name_scope(scope, 'BooleanMask'):
+ if indicator.shape.ndims != 1:
+ raise ValueError('indicator should have rank 1')
+ if indicator.dtype != tf.bool:
+ raise ValueError('indicator should be a boolean tensor')
+ if use_static_shapes:
+ if not (indicator_sum and isinstance(indicator_sum, int)):
+ raise ValueError('`indicator_sum` must be a of type int')
+ selected_positions = tf.cast(indicator, dtype=tf.float32)
+ indexed_positions = tf.cast(
+ tf.multiply(
+ tf.cumsum(selected_positions), selected_positions),
+ dtype=tf.int32)
+ one_hot_selector = tf.one_hot(
+ indexed_positions - 1, indicator_sum, dtype=tf.float32)
+ sampled_indices = tf.cast(
+ tf.tensordot(
+ tf.cast(tf.range(tf.shape(indicator)[0]), dtype=tf.float32),
+ one_hot_selector,
+ axes=[0, 0]),
+ dtype=tf.int32)
+ return gather(boxlist, sampled_indices, use_static_shapes=True)
+ else:
+ subboxlist = box_list.BoxList(tf.boolean_mask(boxlist.get(), indicator))
+ if fields is None:
+ fields = boxlist.get_extra_fields()
+ for field in fields:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ subfieldlist = tf.boolean_mask(boxlist.get_field(field), indicator)
+ subboxlist.add_field(field, subfieldlist)
+ return subboxlist
+
+
+def gather(boxlist, indices, fields=None, scope=None, use_static_shapes=False):
+ """Gather boxes from BoxList according to indices and return new BoxList.
+
+ By default, `gather` returns boxes corresponding to the input index list, as
+ well as all additional fields stored in the boxlist (indexing into the
+ first dimension). However one can optionally only gather from a
+ subset of fields.
+
+ Args:
+ boxlist: BoxList holding N boxes
+ indices: a rank-1 tensor of type int32 / int64
+ fields: (optional) list of fields to also gather from. If None (default),
+ all fields are gathered from. Pass an empty fields list to only gather
+ the box coordinates.
+ scope: name scope.
+ use_static_shapes: Whether to use an implementation with static shape
+ gurantees.
+
+ Returns:
+ subboxlist: a BoxList corresponding to the subset of the input BoxList
+ specified by indices
+ Raises:
+ ValueError: if specified field is not contained in boxlist or if the
+ indices are not of type int32
+ """
+ with tf.name_scope(scope, 'Gather'):
+ if len(indices.shape.as_list()) != 1:
+ raise ValueError('indices should have rank 1')
+ if indices.dtype != tf.int32 and indices.dtype != tf.int64:
+ raise ValueError('indices should be an int32 / int64 tensor')
+ gather_op = tf.gather
+ if use_static_shapes:
+ gather_op = ops.matmul_gather_on_zeroth_axis
+ subboxlist = box_list.BoxList(gather_op(boxlist.get(), indices))
+ if fields is None:
+ fields = boxlist.get_extra_fields()
+ fields += ['boxes']
+ for field in fields:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all specified fields')
+ subfieldlist = gather_op(boxlist.get_field(field), indices)
+ subboxlist.add_field(field, subfieldlist)
+ return subboxlist
+
+
+def concatenate(boxlists, fields=None, scope=None):
+ """Concatenate list of BoxLists.
+
+ This op concatenates a list of input BoxLists into a larger BoxList. It also
+ handles concatenation of BoxList fields as long as the field tensor shapes
+ are equal except for the first dimension.
+
+ Args:
+ boxlists: list of BoxList objects
+ fields: optional list of fields to also concatenate. By default, all
+ fields from the first BoxList in the list are included in the
+ concatenation.
+ scope: name scope.
+
+ Returns:
+ a BoxList with number of boxes equal to
+ sum([boxlist.num_boxes() for boxlist in BoxList])
+ Raises:
+ ValueError: if boxlists is invalid (i.e., is not a list, is empty, or
+ contains non BoxList objects), or if requested fields are not contained in
+ all boxlists
+ """
+ with tf.name_scope(scope, 'Concatenate'):
+ if not isinstance(boxlists, list):
+ raise ValueError('boxlists should be a list')
+ if not boxlists:
+ raise ValueError('boxlists should have nonzero length')
+ for boxlist in boxlists:
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('all elements of boxlists should be BoxList objects')
+ concatenated = box_list.BoxList(
+ tf.concat([boxlist.get() for boxlist in boxlists], 0))
+ if fields is None:
+ fields = boxlists[0].get_extra_fields()
+ for field in fields:
+ first_field_shape = boxlists[0].get_field(field).get_shape().as_list()
+ first_field_shape[0] = -1
+ if None in first_field_shape:
+ raise ValueError('field %s must have fully defined shape except for the'
+ ' 0th dimension.' % field)
+ for boxlist in boxlists:
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain all requested fields')
+ field_shape = boxlist.get_field(field).get_shape().as_list()
+ field_shape[0] = -1
+ if field_shape != first_field_shape:
+ raise ValueError('field %s must have same shape for all boxlists '
+ 'except for the 0th dimension.' % field)
+ concatenated_field = tf.concat(
+ [boxlist.get_field(field) for boxlist in boxlists], 0)
+ concatenated.add_field(field, concatenated_field)
+ return concatenated
+
+
+def sort_by_field(boxlist, field, order=SortOrder.descend, scope=None):
+ """Sort boxes and associated fields according to a scalar field.
+
+ A common use case is reordering the boxes according to descending scores.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ field: A BoxList field for sorting and reordering the BoxList.
+ order: (Optional) descend or ascend. Default is descend.
+ scope: name scope.
+
+ Returns:
+ sorted_boxlist: A sorted BoxList with the field in the specified order.
+
+ Raises:
+ ValueError: if specified field does not exist
+ ValueError: if the order is not either descend or ascend
+ """
+ with tf.name_scope(scope, 'SortByField'):
+ if order != SortOrder.descend and order != SortOrder.ascend:
+ raise ValueError('Invalid sort order')
+
+ field_to_sort = boxlist.get_field(field)
+ if len(field_to_sort.shape.as_list()) != 1:
+ raise ValueError('Field should have rank 1')
+
+ num_boxes = boxlist.num_boxes()
+ num_entries = tf.size(field_to_sort)
+ length_assert = tf.Assert(
+ tf.equal(num_boxes, num_entries),
+ ['Incorrect field size: actual vs expected.', num_entries, num_boxes])
+
+ with tf.control_dependencies([length_assert]):
+ _, sorted_indices = tf.nn.top_k(field_to_sort, num_boxes, sorted=True)
+
+ if order == SortOrder.ascend:
+ sorted_indices = tf.reverse_v2(sorted_indices, [0])
+
+ return gather(boxlist, sorted_indices)
+
+
+def visualize_boxes_in_image(image, boxlist, normalized=False, scope=None):
+ """Overlay bounding box list on image.
+
+ Currently this visualization plots a 1 pixel thick red bounding box on top
+ of the image. Note that tf.image.draw_bounding_boxes essentially is
+ 1 indexed.
+
+ Args:
+ image: an image tensor with shape [height, width, 3]
+ boxlist: a BoxList
+ normalized: (boolean) specify whether corners are to be interpreted
+ as absolute coordinates in image space or normalized with respect to the
+ image size.
+ scope: name scope.
+
+ Returns:
+ image_and_boxes: an image tensor with shape [height, width, 3]
+ """
+ with tf.name_scope(scope, 'VisualizeBoxesInImage'):
+ if not normalized:
+ height, width, _ = tf.unstack(tf.shape(image))
+ boxlist = scale(boxlist,
+ 1.0 / tf.cast(height, tf.float32),
+ 1.0 / tf.cast(width, tf.float32))
+ corners = tf.expand_dims(boxlist.get(), 0)
+ image = tf.expand_dims(image, 0)
+ return tf.squeeze(tf.image.draw_bounding_boxes(image, corners), [0])
+
+
+def filter_field_value_equals(boxlist, field, value, scope=None):
+ """Filter to keep only boxes with field entries equal to the given value.
+
+ Args:
+ boxlist: BoxList holding N boxes.
+ field: field name for filtering.
+ value: scalar value.
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= N
+
+ Raises:
+ ValueError: if boxlist not a BoxList object or if it does not have
+ the specified field.
+ """
+ with tf.name_scope(scope, 'FilterFieldValueEquals'):
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field(field):
+ raise ValueError('boxlist must contain the specified field')
+ filter_field = boxlist.get_field(field)
+ gather_index = tf.reshape(tf.where(tf.equal(filter_field, value)), [-1])
+ return gather(boxlist, gather_index)
+
+
+def filter_greater_than(boxlist, thresh, scope=None):
+ """Filter to keep only boxes with score exceeding a given threshold.
+
+ This op keeps the collection of boxes whose corresponding scores are
+ greater than the input threshold.
+
+ TODO(jonathanhuang): Change function name to filter_scores_greater_than
+
+ Args:
+ boxlist: BoxList holding N boxes. Must contain a 'scores' field
+ representing detection scores.
+ thresh: scalar threshold
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= N
+
+ Raises:
+ ValueError: if boxlist not a BoxList object or if it does not
+ have a scores field
+ """
+ with tf.name_scope(scope, 'FilterGreaterThan'):
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field('scores'):
+ raise ValueError('input boxlist must have \'scores\' field')
+ scores = boxlist.get_field('scores')
+ if len(scores.shape.as_list()) > 2:
+ raise ValueError('Scores should have rank 1 or 2')
+ if len(scores.shape.as_list()) == 2 and scores.shape.as_list()[1] != 1:
+ raise ValueError('Scores should have rank 1 or have shape '
+ 'consistent with [None, 1]')
+ high_score_indices = tf.cast(tf.reshape(
+ tf.where(tf.greater(scores, thresh)),
+ [-1]), tf.int32)
+ return gather(boxlist, high_score_indices)
+
+
+def non_max_suppression(boxlist, thresh, max_output_size, scope=None):
+ """Non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. Note that this only works for a single class ---
+ to apply NMS to multi-class predictions, use MultiClassNonMaxSuppression.
+
+ Args:
+ boxlist: BoxList holding N boxes. Must contain a 'scores' field
+ representing detection scores.
+ thresh: scalar threshold
+ max_output_size: maximum number of retained boxes
+ scope: name scope.
+
+ Returns:
+ a BoxList holding M boxes where M <= max_output_size
+ Raises:
+ ValueError: if thresh is not in [0, 1]
+ """
+ with tf.name_scope(scope, 'NonMaxSuppression'):
+ if not 0 <= thresh <= 1.0:
+ raise ValueError('thresh must be between 0 and 1')
+ if not isinstance(boxlist, box_list.BoxList):
+ raise ValueError('boxlist must be a BoxList')
+ if not boxlist.has_field('scores'):
+ raise ValueError('input boxlist must have \'scores\' field')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist.get(), boxlist.get_field('scores'),
+ max_output_size, iou_threshold=thresh)
+ return gather(boxlist, selected_indices)
+
+
+def _copy_extra_fields(boxlist_to_copy_to, boxlist_to_copy_from):
+ """Copies the extra fields of boxlist_to_copy_from to boxlist_to_copy_to.
+
+ Args:
+ boxlist_to_copy_to: BoxList to which extra fields are copied.
+ boxlist_to_copy_from: BoxList from which fields are copied.
+
+ Returns:
+ boxlist_to_copy_to with extra fields.
+ """
+ for field in boxlist_to_copy_from.get_extra_fields():
+ boxlist_to_copy_to.add_field(field, boxlist_to_copy_from.get_field(field))
+ return boxlist_to_copy_to
+
+
+def to_normalized_coordinates(boxlist, height, width,
+ check_range=True, scope=None):
+ """Converts absolute box coordinates to normalized coordinates in [0, 1].
+
+ Usually one uses the dynamic shape of the image or conv-layer tensor:
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(images)[1],
+ tf.shape(images)[2]),
+
+ This function raises an assertion failed error at graph execution time when
+ the maximum coordinate is smaller than 1.01 (which means that coordinates are
+ already normalized). The value 1.01 is to deal with small rounding errors.
+
+ Args:
+ boxlist: BoxList with coordinates in terms of pixel-locations.
+ height: Maximum value for height of absolute box coordinates.
+ width: Maximum value for width of absolute box coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ scope: name scope.
+
+ Returns:
+ boxlist with normalized coordinates in [0, 1].
+ """
+ with tf.name_scope(scope, 'ToNormalizedCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ if check_range:
+ max_val = tf.reduce_max(boxlist.get())
+ max_assert = tf.Assert(tf.greater(max_val, 1.01),
+ ['max value is lower than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(boxlist, 1 / height, 1 / width)
+
+
+def to_absolute_coordinates(boxlist,
+ height,
+ width,
+ check_range=True,
+ maximum_normalized_coordinate=1.1,
+ scope=None):
+ """Converts normalized box coordinates to absolute pixel coordinates.
+
+ This function raises an assertion failed error when the maximum box coordinate
+ value is larger than maximum_normalized_coordinate (in which case coordinates
+ are already absolute).
+
+ Args:
+ boxlist: BoxList with coordinates in range [0, 1].
+ height: Maximum value for height of absolute box coordinates.
+ width: Maximum value for width of absolute box coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ maximum_normalized_coordinate: Maximum coordinate value to be considered
+ as normalized, default to 1.1.
+ scope: name scope.
+
+ Returns:
+ boxlist with absolute coordinates in terms of the image size.
+
+ """
+ with tf.name_scope(scope, 'ToAbsoluteCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ # Ensure range of input boxes is correct.
+ if check_range:
+ box_maximum = tf.reduce_max(boxlist.get())
+ max_assert = tf.Assert(
+ tf.greater_equal(maximum_normalized_coordinate, box_maximum),
+ ['maximum box coordinate value is larger '
+ 'than %f: ' % maximum_normalized_coordinate, box_maximum])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(boxlist, height, width)
+
+
+def refine_boxes_multi_class(pool_boxes,
+ num_classes,
+ nms_iou_thresh,
+ nms_max_detections,
+ voting_iou_thresh=0.5):
+ """Refines a pool of boxes using non max suppression and box voting.
+
+ Box refinement is done independently for each class.
+
+ Args:
+ pool_boxes: (BoxList) A collection of boxes to be refined. pool_boxes must
+ have a rank 1 'scores' field and a rank 1 'classes' field.
+ num_classes: (int scalar) Number of classes.
+ nms_iou_thresh: (float scalar) iou threshold for non max suppression (NMS).
+ nms_max_detections: (int scalar) maximum output size for NMS.
+ voting_iou_thresh: (float scalar) iou threshold for box voting.
+
+ Returns:
+ BoxList of refined boxes.
+
+ Raises:
+ ValueError: if
+ a) nms_iou_thresh or voting_iou_thresh is not in [0, 1].
+ b) pool_boxes is not a BoxList.
+ c) pool_boxes does not have a scores and classes field.
+ """
+ if not 0.0 <= nms_iou_thresh <= 1.0:
+ raise ValueError('nms_iou_thresh must be between 0 and 1')
+ if not 0.0 <= voting_iou_thresh <= 1.0:
+ raise ValueError('voting_iou_thresh must be between 0 and 1')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+ if not pool_boxes.has_field('classes'):
+ raise ValueError('pool_boxes must have a \'classes\' field')
+
+ refined_boxes = []
+ for i in range(num_classes):
+ boxes_class = filter_field_value_equals(pool_boxes, 'classes', i)
+ refined_boxes_class = refine_boxes(boxes_class, nms_iou_thresh,
+ nms_max_detections, voting_iou_thresh)
+ refined_boxes.append(refined_boxes_class)
+ return sort_by_field(concatenate(refined_boxes), 'scores')
+
+
+def refine_boxes(pool_boxes,
+ nms_iou_thresh,
+ nms_max_detections,
+ voting_iou_thresh=0.5):
+ """Refines a pool of boxes using non max suppression and box voting.
+
+ Args:
+ pool_boxes: (BoxList) A collection of boxes to be refined. pool_boxes must
+ have a rank 1 'scores' field.
+ nms_iou_thresh: (float scalar) iou threshold for non max suppression (NMS).
+ nms_max_detections: (int scalar) maximum output size for NMS.
+ voting_iou_thresh: (float scalar) iou threshold for box voting.
+
+ Returns:
+ BoxList of refined boxes.
+
+ Raises:
+ ValueError: if
+ a) nms_iou_thresh or voting_iou_thresh is not in [0, 1].
+ b) pool_boxes is not a BoxList.
+ c) pool_boxes does not have a scores field.
+ """
+ if not 0.0 <= nms_iou_thresh <= 1.0:
+ raise ValueError('nms_iou_thresh must be between 0 and 1')
+ if not 0.0 <= voting_iou_thresh <= 1.0:
+ raise ValueError('voting_iou_thresh must be between 0 and 1')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+
+ nms_boxes = non_max_suppression(
+ pool_boxes, nms_iou_thresh, nms_max_detections)
+ return box_voting(nms_boxes, pool_boxes, voting_iou_thresh)
+
+
+def box_voting(selected_boxes, pool_boxes, iou_thresh=0.5):
+ """Performs box voting as described in S. Gidaris and N. Komodakis, ICCV 2015.
+
+ Performs box voting as described in 'Object detection via a multi-region &
+ semantic segmentation-aware CNN model', Gidaris and Komodakis, ICCV 2015. For
+ each box 'B' in selected_boxes, we find the set 'S' of boxes in pool_boxes
+ with iou overlap >= iou_thresh. The location of B is set to the weighted
+ average location of boxes in S (scores are used for weighting). And the score
+ of B is set to the average score of boxes in S.
+
+ Args:
+ selected_boxes: BoxList containing a subset of boxes in pool_boxes. These
+ boxes are usually selected from pool_boxes using non max suppression.
+ pool_boxes: BoxList containing a set of (possibly redundant) boxes.
+ iou_thresh: (float scalar) iou threshold for matching boxes in
+ selected_boxes and pool_boxes.
+
+ Returns:
+ BoxList containing averaged locations and scores for each box in
+ selected_boxes.
+
+ Raises:
+ ValueError: if
+ a) selected_boxes or pool_boxes is not a BoxList.
+ b) if iou_thresh is not in [0, 1].
+ c) pool_boxes does not have a scores field.
+ """
+ if not 0.0 <= iou_thresh <= 1.0:
+ raise ValueError('iou_thresh must be between 0 and 1')
+ if not isinstance(selected_boxes, box_list.BoxList):
+ raise ValueError('selected_boxes must be a BoxList')
+ if not isinstance(pool_boxes, box_list.BoxList):
+ raise ValueError('pool_boxes must be a BoxList')
+ if not pool_boxes.has_field('scores'):
+ raise ValueError('pool_boxes must have a \'scores\' field')
+
+ iou_ = iou(selected_boxes, pool_boxes)
+ match_indicator = tf.cast(tf.greater(iou_, iou_thresh), dtype=tf.float32)
+ num_matches = tf.reduce_sum(match_indicator, 1)
+ # TODO(kbanoop): Handle the case where some boxes in selected_boxes do not
+ # match to any boxes in pool_boxes. For such boxes without any matches, we
+ # should return the original boxes without voting.
+ match_assert = tf.Assert(
+ tf.reduce_all(tf.greater(num_matches, 0)),
+ ['Each box in selected_boxes must match with at least one box '
+ 'in pool_boxes.'])
+
+ scores = tf.expand_dims(pool_boxes.get_field('scores'), 1)
+ scores_assert = tf.Assert(
+ tf.reduce_all(tf.greater_equal(scores, 0)),
+ ['Scores must be non negative.'])
+
+ with tf.control_dependencies([scores_assert, match_assert]):
+ sum_scores = tf.matmul(match_indicator, scores)
+ averaged_scores = tf.reshape(sum_scores, [-1]) / num_matches
+
+ box_locations = tf.matmul(match_indicator,
+ pool_boxes.get() * scores) / sum_scores
+ averaged_boxes = box_list.BoxList(box_locations)
+ _copy_extra_fields(averaged_boxes, selected_boxes)
+ averaged_boxes.add_field('scores', averaged_scores)
+ return averaged_boxes
+
+
+def pad_or_clip_box_list(boxlist, num_boxes, scope=None):
+ """Pads or clips all fields of a BoxList.
+
+ Args:
+ boxlist: A BoxList with arbitrary of number of boxes.
+ num_boxes: First num_boxes in boxlist are kept.
+ The fields are zero-padded if num_boxes is bigger than the
+ actual number of boxes.
+ scope: name scope.
+
+ Returns:
+ BoxList with all fields padded or clipped.
+ """
+ with tf.name_scope(scope, 'PadOrClipBoxList'):
+ subboxlist = box_list.BoxList(shape_utils.pad_or_clip_tensor(
+ boxlist.get(), num_boxes))
+ for field in boxlist.get_extra_fields():
+ subfield = shape_utils.pad_or_clip_tensor(
+ boxlist.get_field(field), num_boxes)
+ subboxlist.add_field(field, subfield)
+ return subboxlist
+
+
+def select_random_box(boxlist,
+ default_box=None,
+ seed=None,
+ scope=None):
+ """Selects a random bounding box from a `BoxList`.
+
+ Args:
+ boxlist: A BoxList.
+ default_box: A [1, 4] float32 tensor. If no boxes are present in `boxlist`,
+ this default box will be returned. If None, will use a default box of
+ [[-1., -1., -1., -1.]].
+ seed: Random seed.
+ scope: Name scope.
+
+ Returns:
+ bbox: A [1, 4] tensor with a random bounding box.
+ valid: A bool tensor indicating whether a valid bounding box is returned
+ (True) or whether the default box is returned (False).
+ """
+ with tf.name_scope(scope, 'SelectRandomBox'):
+ bboxes = boxlist.get()
+ combined_shape = shape_utils.combined_static_and_dynamic_shape(bboxes)
+ number_of_boxes = combined_shape[0]
+ default_box = default_box or tf.constant([[-1., -1., -1., -1.]])
+
+ def select_box():
+ random_index = tf.random_uniform([],
+ maxval=number_of_boxes,
+ dtype=tf.int32,
+ seed=seed)
+ return tf.expand_dims(bboxes[random_index], axis=0), tf.constant(True)
+
+ return tf.cond(
+ tf.greater_equal(number_of_boxes, 1),
+ true_fn=select_box,
+ false_fn=lambda: (default_box, tf.constant(False)))
+
+
+def get_minimal_coverage_box(boxlist,
+ default_box=None,
+ scope=None):
+ """Creates a single bounding box which covers all boxes in the boxlist.
+
+ Args:
+ boxlist: A Boxlist.
+ default_box: A [1, 4] float32 tensor. If no boxes are present in `boxlist`,
+ this default box will be returned. If None, will use a default box of
+ [[0., 0., 1., 1.]].
+ scope: Name scope.
+
+ Returns:
+ A [1, 4] float32 tensor with a bounding box that tightly covers all the
+ boxes in the box list. If the boxlist does not contain any boxes, the
+ default box is returned.
+ """
+ with tf.name_scope(scope, 'CreateCoverageBox'):
+ num_boxes = boxlist.num_boxes()
+
+ def coverage_box(bboxes):
+ y_min, x_min, y_max, x_max = tf.split(
+ value=bboxes, num_or_size_splits=4, axis=1)
+ y_min_coverage = tf.reduce_min(y_min, axis=0)
+ x_min_coverage = tf.reduce_min(x_min, axis=0)
+ y_max_coverage = tf.reduce_max(y_max, axis=0)
+ x_max_coverage = tf.reduce_max(x_max, axis=0)
+ return tf.stack(
+ [y_min_coverage, x_min_coverage, y_max_coverage, x_max_coverage],
+ axis=1)
+
+ default_box = default_box or tf.constant([[0., 0., 1., 1.]])
+ return tf.cond(
+ tf.greater_equal(num_boxes, 1),
+ true_fn=lambda: coverage_box(boxlist.get()),
+ false_fn=lambda: default_box)
+
+
+def sample_boxes_by_jittering(boxlist,
+ num_boxes_to_sample,
+ stddev=0.1,
+ scope=None):
+ """Samples num_boxes_to_sample boxes by jittering around boxlist boxes.
+
+ It is possible that this function might generate boxes with size 0. The larger
+ the stddev, this is more probable. For a small stddev of 0.1 this probability
+ is very small.
+
+ Args:
+ boxlist: A boxlist containing N boxes in normalized coordinates.
+ num_boxes_to_sample: A positive integer containing the number of boxes to
+ sample.
+ stddev: Standard deviation. This is used to draw random offsets for the
+ box corners from a normal distribution. The offset is multiplied by the
+ box size so will be larger in terms of pixels for larger boxes.
+ scope: Name scope.
+
+ Returns:
+ sampled_boxlist: A boxlist containing num_boxes_to_sample boxes in
+ normalized coordinates.
+ """
+ with tf.name_scope(scope, 'SampleBoxesByJittering'):
+ num_boxes = boxlist.num_boxes()
+ box_indices = tf.random_uniform(
+ [num_boxes_to_sample],
+ minval=0,
+ maxval=num_boxes,
+ dtype=tf.int32)
+ sampled_boxes = tf.gather(boxlist.get(), box_indices)
+ sampled_boxes_height = sampled_boxes[:, 2] - sampled_boxes[:, 0]
+ sampled_boxes_width = sampled_boxes[:, 3] - sampled_boxes[:, 1]
+ rand_miny_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_minx_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_maxy_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ rand_maxx_gaussian = tf.random_normal([num_boxes_to_sample], stddev=stddev)
+ miny = rand_miny_gaussian * sampled_boxes_height + sampled_boxes[:, 0]
+ minx = rand_minx_gaussian * sampled_boxes_width + sampled_boxes[:, 1]
+ maxy = rand_maxy_gaussian * sampled_boxes_height + sampled_boxes[:, 2]
+ maxx = rand_maxx_gaussian * sampled_boxes_width + sampled_boxes[:, 3]
+ maxy = tf.maximum(miny, maxy)
+ maxx = tf.maximum(minx, maxx)
+ sampled_boxes = tf.stack([miny, minx, maxy, maxx], axis=1)
+ sampled_boxes = tf.maximum(tf.minimum(sampled_boxes, 1.0), 0.0)
+ return box_list.BoxList(sampled_boxes)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops_test.py
new file mode 100644
index 00000000..efe29913
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_ops_test.py
@@ -0,0 +1,1108 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_list_ops."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.utils import test_case
+
+
+class BoxListOpsTest(test_case.TestCase):
+ """Tests for common bounding box operations."""
+
+ def test_area(self):
+ corners = tf.constant([[0.0, 0.0, 10.0, 20.0], [1.0, 2.0, 3.0, 4.0]])
+ exp_output = [200.0, 4.0]
+ boxes = box_list.BoxList(corners)
+ areas = box_list_ops.area(boxes)
+ with self.test_session() as sess:
+ areas_output = sess.run(areas)
+ self.assertAllClose(areas_output, exp_output)
+
+ def test_height_width(self):
+ corners = tf.constant([[0.0, 0.0, 10.0, 20.0], [1.0, 2.0, 3.0, 4.0]])
+ exp_output_heights = [10., 2.]
+ exp_output_widths = [20., 2.]
+ boxes = box_list.BoxList(corners)
+ heights, widths = box_list_ops.height_width(boxes)
+ with self.test_session() as sess:
+ output_heights, output_widths = sess.run([heights, widths])
+ self.assertAllClose(output_heights, exp_output_heights)
+ self.assertAllClose(output_widths, exp_output_widths)
+
+ def test_scale(self):
+ corners = tf.constant([[0, 0, 100, 200], [50, 120, 100, 140]],
+ dtype=tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2]]))
+
+ y_scale = tf.constant(1.0/100)
+ x_scale = tf.constant(1.0/200)
+ scaled_boxes = box_list_ops.scale(boxes, y_scale, x_scale)
+ exp_output = [[0, 0, 1, 1], [0.5, 0.6, 1.0, 0.7]]
+ with self.test_session() as sess:
+ scaled_corners_out = sess.run(scaled_boxes.get())
+ self.assertAllClose(scaled_corners_out, exp_output)
+ extra_data_out = sess.run(scaled_boxes.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2]])
+
+ def test_clip_to_window_filter_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0],
+ [-10.0, -10.0, -9.0, -9.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0], [0.0, 0.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0], [0.0, 0.0, 9.0, 14.0],
+ [0.0, 0.0, 9.0, 14.0]]
+ pruned = box_list_ops.clip_to_window(
+ boxes, window, filter_nonoverlapping=True)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [5]])
+
+ def test_clip_to_window_without_filtering_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0],
+ [-10.0, -10.0, -9.0, -9.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0], [0.0, 0.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0], [0.0, 0.0, 9.0, 14.0],
+ [0.0, 0.0, 9.0, 14.0], [0.0, 0.0, 0.0, 0.0]]
+ pruned = box_list_ops.clip_to_window(
+ boxes, window, filter_nonoverlapping=False)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [5], [6]])
+
+ def test_prune_outside_window_filters_boxes_which_fall_outside_the_window(
+ self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-10.0, -10.0, -9.0, -9.0],
+ [-100.0, -100.0, 300.0, 600.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0]]
+ pruned, keep_indices = box_list_ops.prune_outside_window(boxes, window)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ keep_indices_out = sess.run(keep_indices)
+ self.assertAllEqual(keep_indices_out, [0, 2, 3])
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [3], [4]])
+
+ def test_prune_completely_outside_window(self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.constant([[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-10.0, -10.0, -9.0, -9.0],
+ [-100.0, -100.0, 300.0, 600.0]])
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.constant([[1], [2], [3], [4], [5], [6]]))
+ exp_output = [[5.0, 5.0, 6.0, 6.0],
+ [-1.0, -2.0, 4.0, 5.0],
+ [2.0, 3.0, 5.0, 9.0],
+ [0.0, 0.0, 9.0, 14.0],
+ [-100.0, -100.0, 300.0, 600.0]]
+ pruned, keep_indices = box_list_ops.prune_completely_outside_window(boxes,
+ window)
+ with self.test_session() as sess:
+ pruned_output = sess.run(pruned.get())
+ self.assertAllClose(pruned_output, exp_output)
+ keep_indices_out = sess.run(keep_indices)
+ self.assertAllEqual(keep_indices_out, [0, 1, 2, 3, 5])
+ extra_data_out = sess.run(pruned.get_field('extra_data'))
+ self.assertAllEqual(extra_data_out, [[1], [2], [3], [4], [6]])
+
+ def test_prune_completely_outside_window_with_empty_boxlist(self):
+ window = tf.constant([0, 0, 9, 14], tf.float32)
+ corners = tf.zeros(shape=[0, 4], dtype=tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('extra_data', tf.zeros(shape=[0], dtype=tf.int32))
+ pruned, keep_indices = box_list_ops.prune_completely_outside_window(boxes,
+ window)
+ pruned_boxes = pruned.get()
+ extra = pruned.get_field('extra_data')
+
+ exp_pruned_boxes = np.zeros(shape=[0, 4], dtype=np.float32)
+ exp_extra = np.zeros(shape=[0], dtype=np.int32)
+ with self.test_session() as sess:
+ pruned_boxes_out, keep_indices_out, extra_out = sess.run(
+ [pruned_boxes, keep_indices, extra])
+ self.assertAllClose(exp_pruned_boxes, pruned_boxes_out)
+ self.assertAllEqual([], keep_indices_out)
+ self.assertAllEqual(exp_extra, extra_out)
+
+ def test_intersection(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0, 0.0, 6.0], [1.0, 0.0, 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ intersect = box_list_ops.intersection(boxes1, boxes2)
+ with self.test_session() as sess:
+ intersect_output = sess.run(intersect)
+ self.assertAllClose(intersect_output, exp_output)
+
+ def test_matched_intersection(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
+ exp_output = [2.0, 0.0]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ intersect = box_list_ops.matched_intersection(boxes1, boxes2)
+ with self.test_session() as sess:
+ intersect_output = sess.run(intersect)
+ self.assertAllClose(intersect_output, exp_output)
+
+ def test_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0 / 16.0, 0, 6.0 / 400.0], [1.0 / 16.0, 0.0, 5.0 / 400.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou = box_list_ops.iou(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_matched_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0]])
+ exp_output = [2.0 / 16.0, 0]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou = box_list_ops.matched_iou(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_iouworks_on_empty_inputs(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ boxes_empty = box_list.BoxList(tf.zeros((0, 4)))
+ iou_empty_1 = box_list_ops.iou(boxes1, boxes_empty)
+ iou_empty_2 = box_list_ops.iou(boxes_empty, boxes2)
+ iou_empty_3 = box_list_ops.iou(boxes_empty, boxes_empty)
+ with self.test_session() as sess:
+ iou_output_1, iou_output_2, iou_output_3 = sess.run(
+ [iou_empty_1, iou_empty_2, iou_empty_3])
+ self.assertAllEqual(iou_output_1.shape, (2, 0))
+ self.assertAllEqual(iou_output_2.shape, (0, 3))
+ self.assertAllEqual(iou_output_3.shape, (0, 0))
+
+ def test_ioa(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output_1 = [[2.0 / 12.0, 0, 6.0 / 400.0],
+ [1.0 / 12.0, 0.0, 5.0 / 400.0]]
+ exp_output_2 = [[2.0 / 6.0, 1.0 / 5.0],
+ [0, 0],
+ [6.0 / 6.0, 5.0 / 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ ioa_1 = box_list_ops.ioa(boxes1, boxes2)
+ ioa_2 = box_list_ops.ioa(boxes2, boxes1)
+ with self.test_session() as sess:
+ ioa_output_1, ioa_output_2 = sess.run([ioa_1, ioa_2])
+ self.assertAllClose(ioa_output_1, exp_output_1)
+ self.assertAllClose(ioa_output_2, exp_output_2)
+
+ def test_prune_non_overlapping_boxes(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ minoverlap = 0.5
+
+ exp_output_1 = boxes1
+ exp_output_2 = box_list.BoxList(tf.constant(0.0, shape=[0, 4]))
+ output_1, keep_indices_1 = box_list_ops.prune_non_overlapping_boxes(
+ boxes1, boxes2, min_overlap=minoverlap)
+ output_2, keep_indices_2 = box_list_ops.prune_non_overlapping_boxes(
+ boxes2, boxes1, min_overlap=minoverlap)
+ with self.test_session() as sess:
+ (output_1_, keep_indices_1_, output_2_, keep_indices_2_, exp_output_1_,
+ exp_output_2_) = sess.run(
+ [output_1.get(), keep_indices_1,
+ output_2.get(), keep_indices_2,
+ exp_output_1.get(), exp_output_2.get()])
+ self.assertAllClose(output_1_, exp_output_1_)
+ self.assertAllClose(output_2_, exp_output_2_)
+ self.assertAllEqual(keep_indices_1_, [0, 1])
+ self.assertAllEqual(keep_indices_2_, [])
+
+ def test_prune_small_boxes(self):
+ boxes = tf.constant([[4.0, 3.0, 7.0, 5.0],
+ [5.0, 6.0, 10.0, 7.0],
+ [3.0, 4.0, 6.0, 8.0],
+ [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_boxes = [[3.0, 4.0, 6.0, 8.0],
+ [0.0, 0.0, 20.0, 20.0]]
+ boxes = box_list.BoxList(boxes)
+ pruned_boxes = box_list_ops.prune_small_boxes(boxes, 3)
+ with self.test_session() as sess:
+ pruned_boxes = sess.run(pruned_boxes.get())
+ self.assertAllEqual(pruned_boxes, exp_boxes)
+
+ def test_prune_small_boxes_prunes_boxes_with_negative_side(self):
+ boxes = tf.constant([[4.0, 3.0, 7.0, 5.0],
+ [5.0, 6.0, 10.0, 7.0],
+ [3.0, 4.0, 6.0, 8.0],
+ [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0],
+ [2.0, 3.0, 1.5, 7.0], # negative height
+ [2.0, 3.0, 5.0, 1.7]]) # negative width
+ exp_boxes = [[3.0, 4.0, 6.0, 8.0],
+ [0.0, 0.0, 20.0, 20.0]]
+ boxes = box_list.BoxList(boxes)
+ pruned_boxes = box_list_ops.prune_small_boxes(boxes, 3)
+ with self.test_session() as sess:
+ pruned_boxes = sess.run(pruned_boxes.get())
+ self.assertAllEqual(pruned_boxes, exp_boxes)
+
+ def test_change_coordinate_frame(self):
+ corners = tf.constant([[0.25, 0.5, 0.75, 0.75], [0.5, 0.0, 1.0, 1.0]])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+ boxes = box_list.BoxList(corners)
+
+ expected_corners = tf.constant([[0, 0.5, 1.0, 1.0], [0.5, -0.5, 1.5, 1.5]])
+ expected_boxes = box_list.BoxList(expected_corners)
+ output = box_list_ops.change_coordinate_frame(boxes, window)
+
+ with self.test_session() as sess:
+ output_, expected_boxes_ = sess.run([output.get(), expected_boxes.get()])
+ self.assertAllClose(output_, expected_boxes_)
+
+ def test_ioaworks_on_empty_inputs(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ boxes_empty = box_list.BoxList(tf.zeros((0, 4)))
+ ioa_empty_1 = box_list_ops.ioa(boxes1, boxes_empty)
+ ioa_empty_2 = box_list_ops.ioa(boxes_empty, boxes2)
+ ioa_empty_3 = box_list_ops.ioa(boxes_empty, boxes_empty)
+ with self.test_session() as sess:
+ ioa_output_1, ioa_output_2, ioa_output_3 = sess.run(
+ [ioa_empty_1, ioa_empty_2, ioa_empty_3])
+ self.assertAllEqual(ioa_output_1.shape, (2, 0))
+ self.assertAllEqual(ioa_output_2.shape, (0, 3))
+ self.assertAllEqual(ioa_output_3.shape, (0, 0))
+
+ def test_pairwise_distances(self):
+ corners1 = tf.constant([[0.0, 0.0, 0.0, 0.0],
+ [1.0, 1.0, 0.0, 2.0]])
+ corners2 = tf.constant([[3.0, 4.0, 1.0, 0.0],
+ [-4.0, 0.0, 0.0, 3.0],
+ [0.0, 0.0, 0.0, 0.0]])
+ exp_output = [[26, 25, 0], [18, 27, 6]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ dist_matrix = box_list_ops.sq_dist(boxes1, boxes2)
+ with self.test_session() as sess:
+ dist_output = sess.run(dist_matrix)
+ self.assertAllClose(dist_output, exp_output)
+
+ def test_boolean_mask(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indicator = tf.constant([True, False, True, False, True], tf.bool)
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ boxes = box_list.BoxList(corners)
+ subset = box_list_ops.boolean_mask(boxes, indicator)
+ with self.test_session() as sess:
+ subset_output = sess.run(subset.get())
+ self.assertAllClose(subset_output, expected_subset)
+
+ def test_static_boolean_mask_with_field(self):
+
+ def graph_fn(corners, weights, indicator):
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.boolean_mask(
+ boxes,
+ indicator, ['weights'],
+ use_static_shapes=True,
+ indicator_sum=3)
+ return (subset.get_field('boxes'), subset.get_field('weights'))
+
+ corners = np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]],
+ dtype=np.float32)
+ indicator = np.array([True, False, True, False, True], dtype=np.bool)
+ weights = np.array([[.1], [.3], [.5], [.7], [.9]], dtype=np.float32)
+ result_boxes, result_weights = self.execute(graph_fn,
+ [corners, weights, indicator])
+ expected_boxes = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ self.assertAllClose(result_boxes, expected_boxes)
+ self.assertAllClose(result_weights, expected_weights)
+
+ def test_dynamic_boolean_mask_with_field(self):
+ corners = tf.placeholder(tf.float32, [None, 4])
+ indicator = tf.placeholder(tf.bool, [None])
+ weights = tf.placeholder(tf.float32, [None, 1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.boolean_mask(boxes, indicator, ['weights'])
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run(
+ [subset.get(), subset.get_field('weights')],
+ feed_dict={
+ corners:
+ np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]]),
+ indicator:
+ np.array([True, False, True, False, True]).astype(np.bool),
+ weights:
+ np.array([[.1], [.3], [.5], [.7], [.9]])
+ })
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_gather(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indices = tf.constant([0, 2, 4], tf.int32)
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ boxes = box_list.BoxList(corners)
+ subset = box_list_ops.gather(boxes, indices)
+ with self.test_session() as sess:
+ subset_output = sess.run(subset.get())
+ self.assertAllClose(subset_output, expected_subset)
+
+ def test_static_gather_with_field(self):
+
+ def graph_fn(corners, weights, indices):
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(
+ boxes, indices, ['weights'], use_static_shapes=True)
+ return (subset.get_field('boxes'), subset.get_field('weights'))
+
+ corners = np.array([4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0],
+ 4 * [4.0]], dtype=np.float32)
+ weights = np.array([[.1], [.3], [.5], [.7], [.9]], dtype=np.float32)
+ indices = np.array([0, 2, 4], dtype=np.int32)
+
+ result_boxes, result_weights = self.execute(graph_fn,
+ [corners, weights, indices])
+ expected_boxes = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+ self.assertAllClose(result_boxes, expected_boxes)
+ self.assertAllClose(result_weights, expected_weights)
+
+ def test_dynamic_gather_with_field(self):
+ corners = tf.placeholder(tf.float32, [None, 4])
+ indices = tf.placeholder(tf.int32, [None])
+ weights = tf.placeholder(tf.float32, [None, 1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [[.1], [.5], [.9]]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(boxes, indices, ['weights'],
+ use_static_shapes=True)
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run(
+ [subset.get(), subset.get_field('weights')],
+ feed_dict={
+ corners:
+ np.array(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]]),
+ indices:
+ np.array([0, 2, 4]).astype(np.int32),
+ weights:
+ np.array([[.1], [.3], [.5], [.7], [.9]])
+ })
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_gather_with_invalid_field(self):
+ corners = tf.constant([4 * [0.0], 4 * [1.0]])
+ indices = tf.constant([0, 1], tf.int32)
+ weights = tf.constant([[.1], [.3]], tf.float32)
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ with self.assertRaises(ValueError):
+ box_list_ops.gather(boxes, indices, ['foo', 'bar'])
+
+ def test_gather_with_invalid_inputs(self):
+ corners = tf.constant(
+ [4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]])
+ indices_float32 = tf.constant([0, 2, 4], tf.float32)
+ boxes = box_list.BoxList(corners)
+ with self.assertRaises(ValueError):
+ _ = box_list_ops.gather(boxes, indices_float32)
+ indices_2d = tf.constant([[0, 2, 4]], tf.int32)
+ boxes = box_list.BoxList(corners)
+ with self.assertRaises(ValueError):
+ _ = box_list_ops.gather(boxes, indices_2d)
+
+ def test_gather_with_dynamic_indexing(self):
+ corners = tf.constant([4 * [0.0], 4 * [1.0], 4 * [2.0], 4 * [3.0], 4 * [4.0]
+ ])
+ weights = tf.constant([.5, .3, .7, .1, .9], tf.float32)
+ indices = tf.reshape(tf.where(tf.greater(weights, 0.4)), [-1])
+ expected_subset = [4 * [0.0], 4 * [2.0], 4 * [4.0]]
+ expected_weights = [.5, .7, .9]
+
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('weights', weights)
+ subset = box_list_ops.gather(boxes, indices, ['weights'])
+ with self.test_session() as sess:
+ subset_output, weights_output = sess.run([subset.get(), subset.get_field(
+ 'weights')])
+ self.assertAllClose(subset_output, expected_subset)
+ self.assertAllClose(weights_output, expected_weights)
+
+ def test_sort_by_field_ascending_order(self):
+ exp_corners = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]]
+ exp_scores = [.95, .9, .75, .6, .5, .3]
+ exp_weights = [.2, .45, .6, .75, .8, .92]
+ shuffle = [2, 4, 0, 5, 1, 3]
+ corners = tf.constant([exp_corners[i] for i in shuffle], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(
+ [exp_scores[i] for i in shuffle], tf.float32))
+ boxes.add_field('weights', tf.constant(
+ [exp_weights[i] for i in shuffle], tf.float32))
+ sort_by_weight = box_list_ops.sort_by_field(
+ boxes,
+ 'weights',
+ order=box_list_ops.SortOrder.ascend)
+ with self.test_session() as sess:
+ corners_out, scores_out, weights_out = sess.run([
+ sort_by_weight.get(),
+ sort_by_weight.get_field('scores'),
+ sort_by_weight.get_field('weights')])
+ self.assertAllClose(corners_out, exp_corners)
+ self.assertAllClose(scores_out, exp_scores)
+ self.assertAllClose(weights_out, exp_weights)
+
+ def test_sort_by_field_descending_order(self):
+ exp_corners = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]]
+ exp_scores = [.95, .9, .75, .6, .5, .3]
+ exp_weights = [.2, .45, .6, .75, .8, .92]
+ shuffle = [2, 4, 0, 5, 1, 3]
+
+ corners = tf.constant([exp_corners[i] for i in shuffle], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(
+ [exp_scores[i] for i in shuffle], tf.float32))
+ boxes.add_field('weights', tf.constant(
+ [exp_weights[i] for i in shuffle], tf.float32))
+
+ sort_by_score = box_list_ops.sort_by_field(boxes, 'scores')
+ with self.test_session() as sess:
+ corners_out, scores_out, weights_out = sess.run([sort_by_score.get(
+ ), sort_by_score.get_field('scores'), sort_by_score.get_field('weights')])
+ self.assertAllClose(corners_out, exp_corners)
+ self.assertAllClose(scores_out, exp_scores)
+ self.assertAllClose(weights_out, exp_weights)
+
+ def test_sort_by_field_invalid_inputs(self):
+ corners = tf.constant([4 * [0.0], 4 * [0.5], 4 * [1.0], 4 * [2.0], 4 *
+ [3.0], 4 * [4.0]])
+ misc = tf.constant([[.95, .9], [.5, .3]], tf.float32)
+ weights = tf.constant([.1, .2], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('misc', misc)
+ boxes.add_field('weights', weights)
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'area')
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'misc')
+
+ with self.assertRaises(ValueError):
+ box_list_ops.sort_by_field(boxes, 'weights')
+
+ def test_visualize_boxes_in_image(self):
+ image = tf.zeros((6, 4, 3))
+ corners = tf.constant([[0, 0, 5, 3],
+ [0, 0, 3, 2]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ image_and_boxes = box_list_ops.visualize_boxes_in_image(image, boxes)
+ image_and_boxes_bw = tf.cast(
+ tf.greater(tf.reduce_sum(image_and_boxes, 2), 0.0), dtype=tf.float32)
+ exp_result = [[1, 1, 1, 0],
+ [1, 1, 1, 0],
+ [1, 1, 1, 0],
+ [1, 0, 1, 0],
+ [1, 1, 1, 0],
+ [0, 0, 0, 0]]
+ with self.test_session() as sess:
+ output = sess.run(image_and_boxes_bw)
+ self.assertAllEqual(output.astype(int), exp_result)
+
+ def test_filter_field_value_equals(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('classes', tf.constant([1, 2, 1, 2, 2, 1]))
+ exp_output1 = [[0, 0, 1, 1], [0, -0.1, 1, 0.9], [0, 100, 1, 101]]
+ exp_output2 = [[0, 0.1, 1, 1.1], [0, 10, 1, 11], [0, 10.1, 1, 11.1]]
+
+ filtered_boxes1 = box_list_ops.filter_field_value_equals(
+ boxes, 'classes', 1)
+ filtered_boxes2 = box_list_ops.filter_field_value_equals(
+ boxes, 'classes', 2)
+ with self.test_session() as sess:
+ filtered_output1, filtered_output2 = sess.run([filtered_boxes1.get(),
+ filtered_boxes2.get()])
+ self.assertAllClose(filtered_output1, exp_output1)
+ self.assertAllClose(filtered_output2, exp_output2)
+
+ def test_filter_greater_than(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.1, .75, .9, .5, .5, .8]))
+ thresh = .6
+ exp_output = [[0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9], [0, 100, 1, 101]]
+
+ filtered_boxes = box_list_ops.filter_greater_than(boxes, thresh)
+ with self.test_session() as sess:
+ filtered_output = sess.run(filtered_boxes.get())
+ self.assertAllClose(filtered_output, exp_output)
+
+ def test_clip_box_list(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8], [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 0, 1, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.65, 0.3, 0.2]))
+ num_boxes = 2
+ clipped_boxlist = box_list_ops.pad_or_clip_box_list(boxlist, num_boxes)
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 0]
+ expected_scores = [0.75, 0.65]
+ with self.test_session() as sess:
+ boxes_out, classes_out, scores_out = sess.run(
+ [clipped_boxlist.get(), clipped_boxlist.get_field('classes'),
+ clipped_boxlist.get_field('scores')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllEqual(expected_classes, classes_out)
+ self.assertAllClose(expected_scores, scores_out)
+
+ def test_pad_box_list(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ num_boxes = 4
+ padded_boxlist = box_list_ops.pad_or_clip_box_list(boxlist, num_boxes)
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0, 0, 0, 0], [0, 0, 0, 0]]
+ expected_classes = [0, 1, 0, 0]
+ expected_scores = [0.75, 0.2, 0, 0]
+ with self.test_session() as sess:
+ boxes_out, classes_out, scores_out = sess.run(
+ [padded_boxlist.get(), padded_boxlist.get_field('classes'),
+ padded_boxlist.get_field('scores')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllEqual(expected_classes, classes_out)
+ self.assertAllClose(expected_scores, scores_out)
+
+ def test_select_random_box(self):
+ boxes = [[0., 0., 1., 1.],
+ [0., 1., 2., 3.],
+ [0., 2., 3., 4.]]
+
+ corners = tf.constant(boxes, dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ random_bbox, valid = box_list_ops.select_random_box(boxlist)
+ with self.test_session() as sess:
+ random_bbox_out, valid_out = sess.run([random_bbox, valid])
+
+ norm_small = any(
+ [np.linalg.norm(random_bbox_out - box) < 1e-6 for box in boxes])
+
+ self.assertTrue(norm_small)
+ self.assertTrue(valid_out)
+
+ def test_select_random_box_with_empty_boxlist(self):
+ corners = tf.constant([], shape=[0, 4], dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ random_bbox, valid = box_list_ops.select_random_box(boxlist)
+ with self.test_session() as sess:
+ random_bbox_out, valid_out = sess.run([random_bbox, valid])
+
+ expected_bbox_out = np.array([[-1., -1., -1., -1.]], dtype=np.float32)
+ self.assertAllEqual(expected_bbox_out, random_bbox_out)
+ self.assertFalse(valid_out)
+
+ def test_get_minimal_coverage_box(self):
+ boxes = [[0., 0., 1., 1.],
+ [-1., 1., 2., 3.],
+ [0., 2., 3., 4.]]
+
+ expected_coverage_box = [[-1., 0., 3., 4.]]
+
+ corners = tf.constant(boxes, dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ coverage_box = box_list_ops.get_minimal_coverage_box(boxlist)
+ with self.test_session() as sess:
+ coverage_box_out = sess.run(coverage_box)
+
+ self.assertAllClose(expected_coverage_box, coverage_box_out)
+
+ def test_get_minimal_coverage_box_with_empty_boxlist(self):
+ corners = tf.constant([], shape=[0, 4], dtype=tf.float32)
+ boxlist = box_list.BoxList(corners)
+ coverage_box = box_list_ops.get_minimal_coverage_box(boxlist)
+ with self.test_session() as sess:
+ coverage_box_out = sess.run(coverage_box)
+
+ self.assertAllClose([[0.0, 0.0, 1.0, 1.0]], coverage_box_out)
+
+
+class ConcatenateTest(tf.test.TestCase):
+
+ def test_invalid_input_box_list_list(self):
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate(None)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([])
+ with self.assertRaises(ValueError):
+ corners = tf.constant([[0, 0, 0, 0]], tf.float32)
+ boxlist = box_list.BoxList(corners)
+ box_list_ops.concatenate([boxlist, 2])
+
+ def test_concatenate_with_missing_fields(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8]], tf.float32)
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([boxlist1, boxlist2])
+
+ def test_concatenate_with_incompatible_field_shapes(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8]], tf.float32)
+ scores2 = tf.constant([[1.0, 1.0], [2.1, 3.2]])
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ boxlist2.add_field('scores', scores2)
+ with self.assertRaises(ValueError):
+ box_list_ops.concatenate([boxlist1, boxlist2])
+
+ def test_concatenate_is_correct(self):
+ corners1 = tf.constant([[0, 0, 0, 0], [1, 2, 3, 4]], tf.float32)
+ scores1 = tf.constant([1.0, 2.1])
+ corners2 = tf.constant([[0, 3, 1, 6], [2, 4, 3, 8], [1, 0, 5, 10]],
+ tf.float32)
+ scores2 = tf.constant([1.0, 2.1, 5.6])
+
+ exp_corners = [[0, 0, 0, 0],
+ [1, 2, 3, 4],
+ [0, 3, 1, 6],
+ [2, 4, 3, 8],
+ [1, 0, 5, 10]]
+ exp_scores = [1.0, 2.1, 1.0, 2.1, 5.6]
+
+ boxlist1 = box_list.BoxList(corners1)
+ boxlist1.add_field('scores', scores1)
+ boxlist2 = box_list.BoxList(corners2)
+ boxlist2.add_field('scores', scores2)
+ result = box_list_ops.concatenate([boxlist1, boxlist2])
+ with self.test_session() as sess:
+ corners_output, scores_output = sess.run(
+ [result.get(), result.get_field('scores')])
+ self.assertAllClose(corners_output, exp_corners)
+ self.assertAllClose(scores_output, exp_scores)
+
+
+class NonMaxSuppressionTest(tf.test.TestCase):
+
+ def test_select_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_at_most_two_boxes_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 2
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_at_most_thirty_boxes_from_three_clusters(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1],
+ [0, -0.1, 1, 0.9],
+ [0, 10, 1, 11],
+ [0, 10.1, 1, 11.1],
+ [0, 100, 1, 101]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9, .75, .6, .95, .5, .3]))
+ iou_thresh = .5
+ max_output_size = 30
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_single_box(self):
+ corners = tf.constant([[0, 0, 1, 1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant([.9]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_select_from_ten_identical_boxes(self):
+ corners = tf.constant(10 * [[0, 0, 1, 1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ boxes.add_field('scores', tf.constant(10 * [.9]))
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 0, 1, 1]]
+ nms = box_list_ops.non_max_suppression(
+ boxes, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_copy_extra_fields(self):
+ corners = tf.constant([[0, 0, 1, 1],
+ [0, 0.1, 1, 1.1]], tf.float32)
+ boxes = box_list.BoxList(corners)
+ tensor1 = np.array([[1], [4]])
+ tensor2 = np.array([[1, 1], [2, 2]])
+ boxes.add_field('tensor1', tf.constant(tensor1))
+ boxes.add_field('tensor2', tf.constant(tensor2))
+ new_boxes = box_list.BoxList(tf.constant([[0, 0, 10, 10],
+ [1, 3, 5, 5]], tf.float32))
+ new_boxes = box_list_ops._copy_extra_fields(new_boxes, boxes)
+ with self.test_session() as sess:
+ self.assertAllClose(tensor1, sess.run(new_boxes.get_field('tensor1')))
+ self.assertAllClose(tensor2, sess.run(new_boxes.get_field('tensor2')))
+
+
+class CoordinatesConversionTest(tf.test.TestCase):
+
+ def test_to_normalized_coordinates(self):
+ coordinates = tf.constant([[0, 0, 100, 100],
+ [25, 25, 75, 75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ normalized_boxlist = box_list_ops.to_normalized_coordinates(
+ boxlist, tf.shape(img)[1], tf.shape(img)[2])
+ expected_boxes = [[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]]
+
+ with self.test_session() as sess:
+ normalized_boxes = sess.run(normalized_boxlist.get())
+ self.assertAllClose(normalized_boxes, expected_boxes)
+
+ def test_to_normalized_coordinates_already_normalized(self):
+ coordinates = tf.constant([[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ normalized_boxlist = box_list_ops.to_normalized_coordinates(
+ boxlist, tf.shape(img)[1], tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(normalized_boxlist.get())
+
+ def test_to_absolute_coordinates(self):
+ coordinates = tf.constant([[0, 0, 1, 1],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ expected_boxes = [[0, 0, 100, 100],
+ [25, 25, 75, 75]]
+
+ with self.test_session() as sess:
+ absolute_boxes = sess.run(absolute_boxlist.get())
+ self.assertAllClose(absolute_boxes, expected_boxes)
+
+ def test_to_absolute_coordinates_already_abolute(self):
+ coordinates = tf.constant([[0, 0, 100, 100],
+ [25, 25, 75, 75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(absolute_boxlist.get())
+
+ def test_convert_to_normalized_and_back(self):
+ coordinates = np.random.uniform(size=(100, 4))
+ coordinates = np.round(np.sort(coordinates) * 200)
+ coordinates[:, 2:4] += 1
+ coordinates[99, :] = [0, 0, 201, 201]
+ img = tf.ones((128, 202, 202, 3))
+
+ boxlist = box_list.BoxList(tf.constant(coordinates, tf.float32))
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ out = sess.run(boxlist.get())
+ self.assertAllClose(out, coordinates)
+
+ def test_convert_to_absolute_and_back(self):
+ coordinates = np.random.uniform(size=(100, 4))
+ coordinates = np.sort(coordinates)
+ coordinates[99, :] = [0, 0, 1, 1]
+ img = tf.ones((128, 202, 202, 3))
+
+ boxlist = box_list.BoxList(tf.constant(coordinates, tf.float32))
+ boxlist = box_list_ops.to_absolute_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+ boxlist = box_list_ops.to_normalized_coordinates(boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2])
+
+ with self.test_session() as sess:
+ out = sess.run(boxlist.get())
+ self.assertAllClose(out, coordinates)
+
+ def test_to_absolute_coordinates_maximum_coordinate_check(self):
+ coordinates = tf.constant([[0, 0, 1.2, 1.2],
+ [0.25, 0.25, 0.75, 0.75]], tf.float32)
+ img = tf.ones((128, 100, 100, 3))
+ boxlist = box_list.BoxList(coordinates)
+ absolute_boxlist = box_list_ops.to_absolute_coordinates(
+ boxlist,
+ tf.shape(img)[1],
+ tf.shape(img)[2],
+ maximum_normalized_coordinate=1.1)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(absolute_boxlist.get())
+
+
+class BoxRefinementTest(tf.test.TestCase):
+
+ def test_box_voting(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ candidates.add_field('ExtraField', tf.constant([1, 2]))
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8]]
+ expected_scores = [0.5, 0.3]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [averaged_boxes.get(), averaged_boxes.get_field('scores'),
+ averaged_boxes.get_field('ExtraField')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [1, 2])
+
+ def test_box_voting_fails_with_negative_scores(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool = box_list.BoxList(tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool.add_field('scores', tf.constant([-0.2]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('Scores must be non negative'):
+ sess.run([averaged_boxes.get()])
+
+ def test_box_voting_fails_when_unmatched(self):
+ candidates = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4]], tf.float32))
+ pool = box_list.BoxList(tf.constant([[0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('scores', tf.constant([0.2]))
+ averaged_boxes = box_list_ops.box_voting(candidates, pool)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('Each box in selected_boxes must match '
+ 'with at least one box in pool_boxes.'):
+ sess.run([averaged_boxes.get()])
+
+ def test_refine_boxes(self):
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8]], tf.float32))
+ pool.add_field('ExtraField', tf.constant([1, 2, 3]))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3]))
+ refined_boxes = box_list_ops.refine_boxes(pool, 0.5, 10)
+
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8]]
+ expected_scores = [0.5, 0.3]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [refined_boxes.get(), refined_boxes.get_field('scores'),
+ refined_boxes.get_field('ExtraField')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [1, 3])
+
+ def test_refine_boxes_multi_class(self):
+ pool = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8], [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ pool.add_field('classes', tf.constant([0, 0, 1, 1]))
+ pool.add_field('scores', tf.constant([0.75, 0.25, 0.3, 0.2]))
+ refined_boxes = box_list_ops.refine_boxes_multi_class(pool, 3, 0.5, 10)
+
+ expected_boxes = [[0.1, 0.1, 0.425, 0.425], [0.6, 0.6, 0.8, 0.8],
+ [0.2, 0.2, 0.3, 0.3]]
+ expected_scores = [0.5, 0.3, 0.2]
+ with self.test_session() as sess:
+ boxes_out, scores_out, extra_field_out = sess.run(
+ [refined_boxes.get(), refined_boxes.get_field('scores'),
+ refined_boxes.get_field('classes')])
+
+ self.assertAllClose(expected_boxes, boxes_out)
+ self.assertAllClose(expected_scores, scores_out)
+ self.assertAllEqual(extra_field_out, [0, 1, 1])
+
+ def test_sample_boxes_by_jittering(self):
+ boxes = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4],
+ [0.1, 0.1, 0.5, 0.5],
+ [0.6, 0.6, 0.8, 0.8],
+ [0.2, 0.2, 0.3, 0.3]], tf.float32))
+ sampled_boxes = box_list_ops.sample_boxes_by_jittering(
+ boxlist=boxes, num_boxes_to_sample=10)
+ iou = box_list_ops.iou(boxes, sampled_boxes)
+ iou_max = tf.reduce_max(iou, axis=0)
+ with self.test_session() as sess:
+ (np_sampled_boxes, np_iou_max) = sess.run([sampled_boxes.get(), iou_max])
+ self.assertAllEqual(np_sampled_boxes.shape, [10, 4])
+ self.assertAllGreater(np_iou_max, 0.5)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_test.py
new file mode 100644
index 00000000..edc00ebb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_list_test.py
@@ -0,0 +1,134 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.box_list."""
+
+import tensorflow as tf
+
+from object_detection.core import box_list
+
+
+class BoxListTest(tf.test.TestCase):
+ """Tests for BoxList class."""
+
+ def test_num_boxes(self):
+ data = tf.constant([[0, 0, 1, 1], [1, 1, 2, 3], [3, 4, 5, 5]], tf.float32)
+ expected_num_boxes = 3
+
+ boxes = box_list.BoxList(data)
+ with self.test_session() as sess:
+ num_boxes_output = sess.run(boxes.num_boxes())
+ self.assertEquals(num_boxes_output, expected_num_boxes)
+
+ def test_get_correct_center_coordinates_and_sizes(self):
+ boxes = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(boxes))
+ centers_sizes = boxes.get_center_coordinates_and_sizes()
+ expected_centers_sizes = [[15, 0.35], [12.5, 0.25], [10, 0.3], [5, 0.3]]
+ with self.test_session() as sess:
+ centers_sizes_out = sess.run(centers_sizes)
+ self.assertAllClose(centers_sizes_out, expected_centers_sizes)
+
+ def test_create_box_list_with_dynamic_shape(self):
+ data = tf.constant([[0, 0, 1, 1], [1, 1, 2, 3], [3, 4, 5, 5]], tf.float32)
+ indices = tf.reshape(tf.where(tf.greater([1, 0, 1], 0)), [-1])
+ data = tf.gather(data, indices)
+ assert data.get_shape().as_list() == [None, 4]
+ expected_num_boxes = 2
+
+ boxes = box_list.BoxList(data)
+ with self.test_session() as sess:
+ num_boxes_output = sess.run(boxes.num_boxes())
+ self.assertEquals(num_boxes_output, expected_num_boxes)
+
+ def test_transpose_coordinates(self):
+ boxes = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(boxes))
+ boxes.transpose_coordinates()
+ expected_corners = [[10.0, 10.0, 15.0, 20.0], [0.1, 0.2, 0.4, 0.5]]
+ with self.test_session() as sess:
+ corners_out = sess.run(boxes.get())
+ self.assertAllClose(corners_out, expected_corners)
+
+ def test_box_list_invalid_inputs(self):
+ data0 = tf.constant([[[0, 0, 1, 1], [3, 4, 5, 5]]], tf.float32)
+ data1 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.float32)
+ data2 = tf.constant([[0, 0, 1], [1, 1, 2], [3, 4, 5]], tf.int32)
+
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data0)
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data1)
+ with self.assertRaises(ValueError):
+ _ = box_list.BoxList(data2)
+
+ def test_num_boxes_static(self):
+ box_corners = [[10.0, 10.0, 20.0, 15.0], [0.2, 0.1, 0.5, 0.4]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+ self.assertEquals(boxes.num_boxes_static(), 2)
+ self.assertEquals(type(boxes.num_boxes_static()), int)
+
+ def test_num_boxes_static_for_uninferrable_shape(self):
+ placeholder = tf.placeholder(tf.float32, shape=[None, 4])
+ boxes = box_list.BoxList(placeholder)
+ self.assertEquals(boxes.num_boxes_static(), None)
+
+ def test_as_tensor_dict(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ tensor_dict = boxlist.as_tensor_dict()
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 1]
+ expected_scores = [0.75, 0.2]
+
+ with self.test_session() as sess:
+ tensor_dict_out = sess.run(tensor_dict)
+ self.assertAllEqual(3, len(tensor_dict_out))
+ self.assertAllClose(expected_boxes, tensor_dict_out['boxes'])
+ self.assertAllEqual(expected_classes, tensor_dict_out['classes'])
+ self.assertAllClose(expected_scores, tensor_dict_out['scores'])
+
+ def test_as_tensor_dict_with_features(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ tensor_dict = boxlist.as_tensor_dict(['boxes', 'classes', 'scores'])
+
+ expected_boxes = [[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]]
+ expected_classes = [0, 1]
+ expected_scores = [0.75, 0.2]
+
+ with self.test_session() as sess:
+ tensor_dict_out = sess.run(tensor_dict)
+ self.assertAllEqual(3, len(tensor_dict_out))
+ self.assertAllClose(expected_boxes, tensor_dict_out['boxes'])
+ self.assertAllEqual(expected_classes, tensor_dict_out['classes'])
+ self.assertAllClose(expected_scores, tensor_dict_out['scores'])
+
+ def test_as_tensor_dict_missing_field(self):
+ boxlist = box_list.BoxList(
+ tf.constant([[0.1, 0.1, 0.4, 0.4], [0.1, 0.1, 0.5, 0.5]], tf.float32))
+ boxlist.add_field('classes', tf.constant([0, 1]))
+ boxlist.add_field('scores', tf.constant([0.75, 0.2]))
+ with self.assertRaises(ValueError):
+ boxlist.as_tensor_dict(['foo', 'bar'])
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_predictor.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_predictor.py
new file mode 100644
index 00000000..91a6647e
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/box_predictor.py
@@ -0,0 +1,227 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Box predictor for object detectors.
+
+Box predictors are classes that take a high level
+image feature map as input and produce two predictions,
+(1) a tensor encoding box locations, and
+(2) a tensor encoding classes for each box.
+
+These components are passed directly to loss functions
+in our detection models.
+
+These modules are separated from the main model since the same
+few box predictor architectures are shared across many models.
+"""
+from abc import abstractmethod
+import tensorflow as tf
+
+BOX_ENCODINGS = 'box_encodings'
+CLASS_PREDICTIONS_WITH_BACKGROUND = 'class_predictions_with_background'
+MASK_PREDICTIONS = 'mask_predictions'
+
+
+class BoxPredictor(object):
+ """BoxPredictor."""
+
+ def __init__(self, is_training, num_classes):
+ """Constructor.
+
+ Args:
+ is_training: Indicates whether the BoxPredictor is in training mode.
+ num_classes: number of classes. Note that num_classes *does not*
+ include the background category, so if groundtruth labels take values
+ in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
+ assigned classification targets can range from {0,... K}).
+ """
+ self._is_training = is_training
+ self._num_classes = num_classes
+
+ @property
+ def is_keras_model(self):
+ return False
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def predict(self, image_features, num_predictions_per_location,
+ scope=None, **params):
+ """Computes encoded object locations and corresponding confidences.
+
+ Takes a list of high level image feature maps as input and produces a list
+ of box encodings and a list of class scores where each element in the output
+ lists correspond to the feature maps in the input list.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ num_predictions_per_location: A list of integers representing the number
+ of box predictions to be made per spatial location for each feature map.
+ scope: Variable and Op scope name.
+ **params: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+
+ Raises:
+ ValueError: If length of `image_features` is not equal to length of
+ `num_predictions_per_location`.
+ """
+ if len(image_features) != len(num_predictions_per_location):
+ raise ValueError('image_feature and num_predictions_per_location must '
+ 'be of same length, found: {} vs {}'.
+ format(len(image_features),
+ len(num_predictions_per_location)))
+ if scope is not None:
+ with tf.variable_scope(scope):
+ return self._predict(image_features, num_predictions_per_location,
+ **params)
+ return self._predict(image_features, num_predictions_per_location,
+ **params)
+
+ # TODO(rathodv): num_predictions_per_location could be moved to constructor.
+ # This is currently only used by ConvolutionalBoxPredictor.
+ @abstractmethod
+ def _predict(self, image_features, num_predictions_per_location, **params):
+ """Implementations must override this method.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ num_predictions_per_location: A list of integers representing the number
+ of box predictions to be made per spatial location for each feature map.
+ **params: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ pass
+
+
+class KerasBoxPredictor(tf.keras.Model):
+ """Keras-based BoxPredictor."""
+
+ def __init__(self, is_training, num_classes, freeze_batchnorm,
+ inplace_batchnorm_update, name=None):
+ """Constructor.
+
+ Args:
+ is_training: Indicates whether the BoxPredictor is in training mode.
+ num_classes: number of classes. Note that num_classes *does not*
+ include the background category, so if groundtruth labels take values
+ in {0, 1, .., K-1}, num_classes=K (and not K+1, even though the
+ assigned classification targets can range from {0,... K}).
+ freeze_batchnorm: Whether to freeze batch norm parameters during
+ training or not. When training with a small batch size (e.g. 1), it is
+ desirable to freeze batch norm update and use pretrained batch norm
+ params.
+ inplace_batchnorm_update: Whether to update batch norm moving average
+ values inplace. When this is false train op must add a control
+ dependency on tf.graphkeys.UPDATE_OPS collection in order to update
+ batch norm statistics.
+ name: A string name scope to assign to the model. If `None`, Keras
+ will auto-generate one from the class name.
+ """
+ super(KerasBoxPredictor, self).__init__(name=name)
+
+ self._is_training = is_training
+ self._num_classes = num_classes
+ self._freeze_batchnorm = freeze_batchnorm
+ self._inplace_batchnorm_update = inplace_batchnorm_update
+
+ @property
+ def is_keras_model(self):
+ return True
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def call(self, image_features, **kwargs):
+ """Computes encoded object locations and corresponding confidences.
+
+ Takes a list of high level image feature maps as input and produces a list
+ of box encodings and a list of class scores where each element in the output
+ lists correspond to the feature maps in the input list.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ **kwargs: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ return self._predict(image_features, **kwargs)
+
+ @abstractmethod
+ def _predict(self, image_features, **kwargs):
+ """Implementations must override this method.
+
+ Args:
+ image_features: A list of float tensors of shape [batch_size, height_i,
+ width_i, channels_i] containing features for a batch of images.
+ **kwargs: Additional keyword arguments for specific implementations of
+ BoxPredictor.
+
+ Returns:
+ A dictionary containing at least the following tensors.
+ box_encodings: A list of float tensors. Each entry in the list
+ corresponds to a feature map in the input `image_features` list. All
+ tensors in the list have one of the two following shapes:
+ a. [batch_size, num_anchors_i, q, code_size] representing the location
+ of the objects, where q is 1 or the number of classes.
+ b. [batch_size, num_anchors_i, code_size].
+ class_predictions_with_background: A list of float tensors of shape
+ [batch_size, num_anchors_i, num_classes + 1] representing the class
+ predictions for the proposals. Each entry in the list corresponds to a
+ feature map in the input `image_features` list.
+ """
+ raise NotImplementedError
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/class_agnostic_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/class_agnostic_nms_test.py
new file mode 100644
index 00000000..8a418b71
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/class_agnostic_nms_test.py
@@ -0,0 +1,155 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for google3.third_party.tensorflow_models.object_detection.core.class_agnostic_nms."""
+from absl.testing import parameterized
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.core import standard_fields as fields
+from object_detection.utils import test_case
+
+
+class ClassAgnosticNonMaxSuppressionTest(test_case.TestCase,
+ parameterized.TestCase):
+
+ def test_class_agnostic_nms_select_with_shared_boxes(self):
+ boxes = tf.constant(
+ [[[0, 0, 1, 1]], [[0, 0.1, 1, 1.1]], [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]], [[0, 10.1, 1, 11.1]], [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]], [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05], [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01], [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_classes_per_detection = 1
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11], [0, 0, 1, 1], [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.class_agnostic_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_classes_per_detection,
+ max_output_size)
+
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)
+ ])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+
+ def test_class_agnostic_nms_select_with_per_class_boxes(self):
+ boxes = tf.constant(
+ [[[4, 5, 9, 10], [0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1], [4, 5, 9, 10]],
+ [[0, -0.1, 1, 0.9], [4, 5, 9, 10]],
+ [[0, 10, 1, 11], [4, 5, 9, 10]],
+ [[0, 10.1, 1, 11.1], [4, 5, 9, 10]],
+ [[0, 100, 1, 101], [4, 5, 9, 10]],
+ [[4, 5, 9, 10], [0, 1000, 1, 1002]],
+ [[4, 5, 9, 10], [0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.01, 0.9],
+ [.75, 0.05],
+ [.6, 0.01],
+ [.95, 0],
+ [.5, 0.01],
+ [.3, 0.01],
+ [.01, .85],
+ [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_classes_per_detection = 1
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 1, 1, 0]
+
+ nms, _ = post_processing.class_agnostic_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_classes_per_detection,
+ max_output_size)
+
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)
+ ])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ # Two cases will be tested here: using / not using static shapes.
+ # Named the two test cases for easier control during testing, with a flag of
+ # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1'
+ # or
+ # '--test_filter=ClassAgnosticNonMaxSuppressionTest.test_batch_classagnostic_nms_with_batch_size_1_use_static_shapes'.
+ @parameterized.named_parameters(('', False), ('_use_static_shapes', True))
+ def test_batch_classagnostic_nms_with_batch_size_1(self,
+ use_static_shapes=False):
+ boxes = tf.constant(
+ [[[[0, 0, 1, 1]], [[0, 0.1, 1, 1.1]], [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]], [[0, 10.1, 1, 11.1]], [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]], [[0, 1000, 1, 1002.1]]]], tf.float32)
+ scores = tf.constant([[[.9, 0.01], [.75, 0.05], [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01], [.01, .85], [.01, .5]]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+ max_classes_per_detection = 1
+ use_class_agnostic_nms = True
+
+ exp_nms_corners = [[[0, 10, 1, 11], [0, 0, 1, 1], [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]]
+ exp_nms_scores = [[.95, .9, .85, .3]]
+ exp_nms_classes = [[0, 0, 1, 0]]
+
+ (nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks,
+ nmsed_additional_fields,
+ num_detections) = post_processing.batch_multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class=max_output_size,
+ max_total_size=max_output_size,
+ use_class_agnostic_nms=use_class_agnostic_nms,
+ use_static_shapes=use_static_shapes,
+ max_classes_per_detection=max_classes_per_detection)
+
+ self.assertIsNone(nmsed_masks)
+ self.assertIsNone(nmsed_additional_fields)
+
+ with self.test_session() as sess:
+ (nmsed_boxes, nmsed_scores, nmsed_classes, num_detections) = sess.run(
+ [nmsed_boxes, nmsed_scores, nmsed_classes, num_detections])
+ self.assertAllClose(nmsed_boxes, exp_nms_corners)
+ self.assertAllClose(nmsed_scores, exp_nms_scores)
+ self.assertAllClose(nmsed_classes, exp_nms_classes)
+ self.assertEqual(num_detections, [4])
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_decoder.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_decoder.py
new file mode 100644
index 00000000..87ddf72c
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_decoder.py
@@ -0,0 +1,44 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Interface for data decoders.
+
+Data decoders decode the input data and return a dictionary of tensors keyed by
+the entries in core.reader.Fields.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from abc import ABCMeta
+from abc import abstractmethod
+import six
+
+
+class DataDecoder(six.with_metaclass(ABCMeta, object)):
+ """Interface for data decoders."""
+
+ @abstractmethod
+ def decode(self, data):
+ """Return a single image and associated labels.
+
+ Args:
+ data: a string tensor holding a serialized protocol buffer corresponding
+ to data for a single image.
+
+ Returns:
+ tensor_dict: a dictionary containing tensors. Possible keys are defined in
+ reader.Fields.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_parser.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_parser.py
new file mode 100644
index 00000000..889545db
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/data_parser.py
@@ -0,0 +1,45 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Interface for data parsers.
+
+Data parser parses input data and returns a dictionary of numpy arrays
+keyed by the entries in standard_fields.py. Since the parser parses records
+to numpy arrays (materialized tensors) directly, it is used to read data for
+evaluation/visualization; to parse the data during training, DataDecoder should
+be used.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from abc import ABCMeta
+from abc import abstractmethod
+import six
+
+
+class DataToNumpyParser(six.with_metaclass(ABCMeta, object)):
+ """Abstract interface for data parser that produces numpy arrays."""
+
+ @abstractmethod
+ def parse(self, input_data):
+ """Parses input and returns a numpy array or a dictionary of numpy arrays.
+
+ Args:
+ input_data: an input data
+
+ Returns:
+ A numpy array or a dictionary of numpy arrays or None, if input
+ cannot be parsed.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm.py
new file mode 100644
index 00000000..be82fcd2
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm.py
@@ -0,0 +1,68 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""A freezable batch norm layer that uses Keras batch normalization."""
+import tensorflow as tf
+
+
+class FreezableBatchNorm(tf.keras.layers.BatchNormalization):
+ """Batch normalization layer (Ioffe and Szegedy, 2014).
+
+ This is a `freezable` batch norm layer that supports setting the `training`
+ parameter in the __init__ method rather than having to set it either via
+ the Keras learning phase or via the `call` method parameter. This layer will
+ forward all other parameters to the default Keras `BatchNormalization`
+ layer
+
+ This is class is necessary because Object Detection model training sometimes
+ requires batch normalization layers to be `frozen` and used as if it was
+ evaluation time, despite still training (and potentially using dropout layers)
+
+ Like the default Keras BatchNormalization layer, this will normalize the
+ activations of the previous layer at each batch,
+ i.e. applies a transformation that maintains the mean activation
+ close to 0 and the activation standard deviation close to 1.
+
+ Arguments:
+ training: If False, the layer will normalize using the moving average and
+ std. dev, without updating the learned avg and std. dev.
+ If None or True, the layer will follow the keras BatchNormalization layer
+ strategy of checking the Keras learning phase at `call` time to decide
+ what to do.
+ **kwargs: The keyword arguments to forward to the keras BatchNormalization
+ layer constructor.
+
+ Input shape:
+ Arbitrary. Use the keyword argument `input_shape`
+ (tuple of integers, does not include the samples axis)
+ when using this layer as the first layer in a model.
+
+ Output shape:
+ Same shape as input.
+
+ References:
+ - [Batch Normalization: Accelerating Deep Network Training by Reducing
+ Internal Covariate Shift](https://arxiv.org/abs/1502.03167)
+ """
+
+ def __init__(self, training=None, **kwargs):
+ super(FreezableBatchNorm, self).__init__(**kwargs)
+ self._training = training
+
+ def call(self, inputs, training=None):
+ # Override the call arg only if the batchnorm is frozen. (Ignore None)
+ if self._training is False: # pylint: disable=g-bool-id-comparison
+ training = self._training
+ return super(FreezableBatchNorm, self).call(inputs, training=training)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm_test.py
new file mode 100644
index 00000000..3e061526
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/freezable_batch_norm_test.py
@@ -0,0 +1,189 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.freezable_batch_norm."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import freezable_batch_norm
+
+
+class FreezableBatchNormTest(tf.test.TestCase):
+ """Tests for FreezableBatchNorm operations."""
+
+ def _build_model(self, training=None):
+ model = tf.keras.models.Sequential()
+ norm = freezable_batch_norm.FreezableBatchNorm(training=training,
+ input_shape=(10,),
+ momentum=0.8)
+ model.add(norm)
+ return model, norm
+
+ def _train_freezable_batch_norm(self, training_mean, training_var):
+ model, _ = self._build_model()
+ model.compile(loss='mse', optimizer='sgd')
+
+ # centered on training_mean, variance training_var
+ train_data = np.random.normal(
+ loc=training_mean,
+ scale=training_var,
+ size=(1000, 10))
+ model.fit(train_data, train_data, epochs=4, verbose=0)
+ return model.weights
+
+ def _test_batchnorm_layer(
+ self, norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg, training_mean, training_var):
+ out_tensor = norm(tf.convert_to_tensor(test_data, dtype=tf.float32),
+ training=training_arg)
+ out = tf.keras.backend.eval(out_tensor)
+ out -= tf.keras.backend.eval(norm.beta)
+ out /= tf.keras.backend.eval(norm.gamma)
+
+ if not should_be_training:
+ out *= training_var
+ out += (training_mean - testing_mean)
+ out /= testing_var
+
+ np.testing.assert_allclose(out.mean(), 0.0, atol=1.5e-1)
+ np.testing.assert_allclose(out.std(), 1.0, atol=1.5e-1)
+
+ def test_batchnorm_freezing_training_none(self):
+ with self.test_session():
+ training_mean = 5.0
+ training_var = 10.0
+
+ testing_mean = -10.0
+ testing_var = 5.0
+
+ # Initially train the batch norm, and save the weights
+ trained_weights = self._train_freezable_batch_norm(training_mean,
+ training_var)
+
+ # Load the batch norm weights, freezing training to True.
+ # Apply the batch norm layer to testing data and ensure it is normalized
+ # according to the batch statistics.
+ model, norm = self._build_model(training=True)
+ for trained_weight, blank_weight in zip(trained_weights, model.weights):
+ weight_copy = blank_weight.assign(tf.keras.backend.eval(trained_weight))
+ tf.keras.backend.eval(weight_copy)
+
+ # centered on testing_mean, variance testing_var
+ test_data = np.random.normal(
+ loc=testing_mean,
+ scale=testing_var,
+ size=(1000, 10))
+
+ # Test with training=True passed to the call method:
+ training_arg = True
+ should_be_training = True
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test with training=False passed to the call method:
+ training_arg = False
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test the layer in various Keras learning phase scopes:
+ training_arg = None
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(True)
+ should_be_training = True
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(False)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ def test_batchnorm_freezing_training_false(self):
+ with self.test_session():
+ training_mean = 5.0
+ training_var = 10.0
+
+ testing_mean = -10.0
+ testing_var = 5.0
+
+ # Initially train the batch norm, and save the weights
+ trained_weights = self._train_freezable_batch_norm(training_mean,
+ training_var)
+
+ # Load the batch norm back up, freezing training to False.
+ # Apply the batch norm layer to testing data and ensure it is normalized
+ # according to the training data's statistics.
+ model, norm = self._build_model(training=False)
+ for trained_weight, blank_weight in zip(trained_weights, model.weights):
+ weight_copy = blank_weight.assign(tf.keras.backend.eval(trained_weight))
+ tf.keras.backend.eval(weight_copy)
+
+ # centered on testing_mean, variance testing_var
+ test_data = np.random.normal(
+ loc=testing_mean,
+ scale=testing_var,
+ size=(1000, 10))
+
+ # Make sure that the layer is never training
+ # Test with training=True passed to the call method:
+ training_arg = True
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test with training=False passed to the call method:
+ training_arg = False
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ # Test the layer in various Keras learning phase scopes:
+ training_arg = None
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(True)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+ tf.keras.backend.set_learning_phase(False)
+ should_be_training = False
+ self._test_batchnorm_layer(norm, should_be_training, test_data,
+ testing_mean, testing_var, training_arg,
+ training_mean, training_var)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops.py
new file mode 100644
index 00000000..e520845f
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops.py
@@ -0,0 +1,282 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Keypoint operations.
+
+Keypoints are represented as tensors of shape [num_instances, num_keypoints, 2],
+where the last dimension holds rank 2 tensors of the form [y, x] representing
+the coordinates of the keypoint.
+"""
+import numpy as np
+import tensorflow as tf
+
+
+def scale(keypoints, y_scale, x_scale, scope=None):
+ """Scales keypoint coordinates in x and y dimensions.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ y_scale: (float) scalar tensor
+ x_scale: (float) scalar tensor
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'Scale'):
+ y_scale = tf.cast(y_scale, tf.float32)
+ x_scale = tf.cast(x_scale, tf.float32)
+ new_keypoints = keypoints * [[[y_scale, x_scale]]]
+ return new_keypoints
+
+
+def clip_to_window(keypoints, window, scope=None):
+ """Clips keypoints to a window.
+
+ This op clips any input keypoints to a window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window to which the op should clip the keypoints.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'ClipToWindow'):
+ y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+ y = tf.maximum(tf.minimum(y, win_y_max), win_y_min)
+ x = tf.maximum(tf.minimum(x, win_x_max), win_x_min)
+ new_keypoints = tf.concat([y, x], 2)
+ return new_keypoints
+
+
+def prune_outside_window(keypoints, window, scope=None):
+ """Prunes keypoints that fall outside a given window.
+
+ This function replaces keypoints that fall outside the given window with nan.
+ See also clip_to_window which clips any keypoints that fall outside the given
+ window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window outside of which the op should prune the keypoints.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'PruneOutsideWindow'):
+ y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window)
+
+ valid_indices = tf.logical_and(
+ tf.logical_and(y >= win_y_min, y <= win_y_max),
+ tf.logical_and(x >= win_x_min, x <= win_x_max))
+
+ new_y = tf.where(valid_indices, y, np.nan * tf.ones_like(y))
+ new_x = tf.where(valid_indices, x, np.nan * tf.ones_like(x))
+ new_keypoints = tf.concat([new_y, new_x], 2)
+
+ return new_keypoints
+
+
+def change_coordinate_frame(keypoints, window, scope=None):
+ """Changes coordinate frame of the keypoints to be relative to window's frame.
+
+ Given a window of the form [y_min, x_min, y_max, x_max], changes keypoint
+ coordinates from keypoints of shape [num_instances, num_keypoints, 2]
+ to be relative to this window.
+
+ An example use case is data augmentation: where we are given groundtruth
+ keypoints and would like to randomly crop the image to some window. In this
+ case we need to change the coordinate frame of each groundtruth keypoint to be
+ relative to this new window.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max]
+ window we should change the coordinate frame to.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'ChangeCoordinateFrame'):
+ win_height = window[2] - window[0]
+ win_width = window[3] - window[1]
+ new_keypoints = scale(keypoints - [window[0], window[1]], 1.0 / win_height,
+ 1.0 / win_width)
+ return new_keypoints
+
+
+def to_normalized_coordinates(keypoints, height, width,
+ check_range=True, scope=None):
+ """Converts absolute keypoint coordinates to normalized coordinates in [0, 1].
+
+ Usually one uses the dynamic shape of the image or conv-layer tensor:
+ keypoints = keypoint_ops.to_normalized_coordinates(keypoints,
+ tf.shape(images)[1],
+ tf.shape(images)[2]),
+
+ This function raises an assertion failed error at graph execution time when
+ the maximum coordinate is smaller than 1.01 (which means that coordinates are
+ already normalized). The value 1.01 is to deal with small rounding errors.
+
+ Args:
+ keypoints: A tensor of shape [num_instances, num_keypoints, 2].
+ height: Maximum value for y coordinate of absolute keypoint coordinates.
+ width: Maximum value for x coordinate of absolute keypoint coordinates.
+ check_range: If True, checks if the coordinates are normalized.
+ scope: name scope.
+
+ Returns:
+ tensor of shape [num_instances, num_keypoints, 2] with normalized
+ coordinates in [0, 1].
+ """
+ with tf.name_scope(scope, 'ToNormalizedCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ if check_range:
+ max_val = tf.reduce_max(keypoints)
+ max_assert = tf.Assert(tf.greater(max_val, 1.01),
+ ['max value is lower than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(keypoints, 1.0 / height, 1.0 / width)
+
+
+def to_absolute_coordinates(keypoints, height, width,
+ check_range=True, scope=None):
+ """Converts normalized keypoint coordinates to absolute pixel coordinates.
+
+ This function raises an assertion failed error when the maximum keypoint
+ coordinate value is larger than 1.01 (in which case coordinates are already
+ absolute).
+
+ Args:
+ keypoints: A tensor of shape [num_instances, num_keypoints, 2]
+ height: Maximum value for y coordinate of absolute keypoint coordinates.
+ width: Maximum value for x coordinate of absolute keypoint coordinates.
+ check_range: If True, checks if the coordinates are normalized or not.
+ scope: name scope.
+
+ Returns:
+ tensor of shape [num_instances, num_keypoints, 2] with absolute coordinates
+ in terms of the image size.
+
+ """
+ with tf.name_scope(scope, 'ToAbsoluteCoordinates'):
+ height = tf.cast(height, tf.float32)
+ width = tf.cast(width, tf.float32)
+
+ # Ensure range of input keypoints is correct.
+ if check_range:
+ max_val = tf.reduce_max(keypoints)
+ max_assert = tf.Assert(tf.greater_equal(1.01, max_val),
+ ['maximum keypoint coordinate value is larger '
+ 'than 1.01: ', max_val])
+ with tf.control_dependencies([max_assert]):
+ width = tf.identity(width)
+
+ return scale(keypoints, height, width)
+
+
+def flip_horizontal(keypoints, flip_point, flip_permutation, scope=None):
+ """Flips the keypoints horizontally around the flip_point.
+
+ This operation flips the x coordinate for each keypoint around the flip_point
+ and also permutes the keypoints in a manner specified by flip_permutation.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ flip_point: (float) scalar tensor representing the x coordinate to flip the
+ keypoints around.
+ flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation. This specifies the mapping from original keypoint indices
+ to the flipped keypoint indices. This is used primarily for keypoints
+ that are not reflection invariant. E.g. Suppose there are 3 keypoints
+ representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+ flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+ and 'right_eye' after a horizontal flip.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'FlipHorizontal'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ keypoints = tf.gather(keypoints, flip_permutation)
+ v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ u = flip_point * 2.0 - u
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
+
+
+def flip_vertical(keypoints, flip_point, flip_permutation, scope=None):
+ """Flips the keypoints vertically around the flip_point.
+
+ This operation flips the y coordinate for each keypoint around the flip_point
+ and also permutes the keypoints in a manner specified by flip_permutation.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ flip_point: (float) scalar tensor representing the y coordinate to flip the
+ keypoints around.
+ flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation. This specifies the mapping from original keypoint indices
+ to the flipped keypoint indices. This is used primarily for keypoints
+ that are not reflection invariant. E.g. Suppose there are 3 keypoints
+ representing ['head', 'right_eye', 'left_eye'], then a logical choice for
+ flip_permutation might be [0, 2, 1] since we want to swap the 'left_eye'
+ and 'right_eye' after a horizontal flip.
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'FlipVertical'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ keypoints = tf.gather(keypoints, flip_permutation)
+ v, u = tf.split(value=keypoints, num_or_size_splits=2, axis=2)
+ v = flip_point * 2.0 - v
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
+
+
+def rot90(keypoints, scope=None):
+ """Rotates the keypoints counter-clockwise by 90 degrees.
+
+ Args:
+ keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ scope: name scope.
+
+ Returns:
+ new_keypoints: a tensor of shape [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope(scope, 'Rot90'):
+ keypoints = tf.transpose(keypoints, [1, 0, 2])
+ v, u = tf.split(value=keypoints[:, :, ::-1], num_or_size_splits=2, axis=2)
+ v = 1.0 - v
+ new_keypoints = tf.concat([v, u], 2)
+ new_keypoints = tf.transpose(new_keypoints, [1, 0, 2])
+ return new_keypoints
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops_test.py
new file mode 100644
index 00000000..1c09c55a
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/keypoint_ops_test.py
@@ -0,0 +1,200 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.keypoint_ops."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import keypoint_ops
+
+
+class KeypointOpsTest(tf.test.TestCase):
+ """Tests for common keypoint operations."""
+
+ def test_scale(self):
+ keypoints = tf.constant([
+ [[0.0, 0.0], [100.0, 200.0]],
+ [[50.0, 120.0], [100.0, 140.0]]
+ ])
+ y_scale = tf.constant(1.0 / 100)
+ x_scale = tf.constant(1.0 / 200)
+
+ expected_keypoints = tf.constant([
+ [[0., 0.], [1.0, 1.0]],
+ [[0.5, 0.6], [1.0, 0.7]]
+ ])
+ output = keypoint_ops.scale(keypoints, y_scale, x_scale)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_clip_to_window(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.25], [0.75, 0.75]]
+ ])
+ output = keypoint_ops.clip_to_window(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_prune_outside_window(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([[[0.25, 0.5], [0.75, 0.75]],
+ [[np.nan, np.nan], [np.nan, np.nan]]])
+ output = keypoint_ops.prune_outside_window(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_change_coordinate_frame(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ window = tf.constant([0.25, 0.25, 0.75, 0.75])
+
+ expected_keypoints = tf.constant([
+ [[0, 0.5], [1.0, 1.0]],
+ [[0.5, -0.5], [1.5, 1.5]]
+ ])
+ output = keypoint_ops.change_coordinate_frame(keypoints, window)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_normalized_coordinates(self):
+ keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+ output = keypoint_ops.to_normalized_coordinates(
+ keypoints, 40, 60)
+ expected_keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_normalized_coordinates_already_normalized(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ output = keypoint_ops.to_normalized_coordinates(
+ keypoints, 40, 60)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(output)
+
+ def test_to_absolute_coordinates(self):
+ keypoints = tf.constant([
+ [[0.25, 0.5], [0.75, 0.75]],
+ [[0.5, 0.0], [1.0, 1.0]]
+ ])
+ output = keypoint_ops.to_absolute_coordinates(
+ keypoints, 40, 60)
+ expected_keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_to_absolute_coordinates_already_absolute(self):
+ keypoints = tf.constant([
+ [[10., 30.], [30., 45.]],
+ [[20., 0.], [40., 60.]]
+ ])
+ output = keypoint_ops.to_absolute_coordinates(
+ keypoints, 40, 60)
+
+ with self.test_session() as sess:
+ with self.assertRaisesOpError('assertion failed'):
+ sess.run(output)
+
+ def test_flip_horizontal(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]
+ ])
+ flip_permutation = [0, 2, 1]
+
+ expected_keypoints = tf.constant([
+ [[0.1, 0.9], [0.3, 0.7], [0.2, 0.8]],
+ [[0.4, 0.6], [0.6, 0.4], [0.5, 0.5]],
+ ])
+ output = keypoint_ops.flip_horizontal(keypoints, 0.5, flip_permutation)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_flip_vertical(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]
+ ])
+ flip_permutation = [0, 2, 1]
+
+ expected_keypoints = tf.constant([
+ [[0.9, 0.1], [0.7, 0.3], [0.8, 0.2]],
+ [[0.6, 0.4], [0.4, 0.6], [0.5, 0.5]],
+ ])
+ output = keypoint_ops.flip_vertical(keypoints, 0.5, flip_permutation)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+ def test_rot90(self):
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.6], [0.5, 0.6], [0.6, 0.7]]
+ ])
+ expected_keypoints = tf.constant([
+ [[0.9, 0.1], [0.8, 0.2], [0.7, 0.3]],
+ [[0.4, 0.4], [0.4, 0.5], [0.3, 0.6]],
+ ])
+ output = keypoint_ops.rot90(keypoints)
+
+ with self.test_session() as sess:
+ output_, expected_keypoints_ = sess.run([output, expected_keypoints])
+ self.assertAllClose(output_, expected_keypoints_)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/losses.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/losses.py
new file mode 100644
index 00000000..b4fa4286
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/losses.py
@@ -0,0 +1,686 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Classification and regression loss functions for object detection.
+
+Localization losses:
+ * WeightedL2LocalizationLoss
+ * WeightedSmoothL1LocalizationLoss
+ * WeightedIOULocalizationLoss
+
+Classification losses:
+ * WeightedSigmoidClassificationLoss
+ * WeightedSoftmaxClassificationLoss
+ * WeightedSoftmaxClassificationAgainstLogitsLoss
+ * BootstrappedSigmoidClassificationLoss
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import abc
+import six
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.utils import ops
+
+slim = tf.contrib.slim
+
+
+class Loss(six.with_metaclass(abc.ABCMeta, object)):
+ """Abstract base class for loss functions."""
+
+ def __call__(self,
+ prediction_tensor,
+ target_tensor,
+ ignore_nan_targets=False,
+ losses_mask=None,
+ scope=None,
+ **params):
+ """Call the loss function.
+
+ Args:
+ prediction_tensor: an N-d tensor of shape [batch, anchors, ...]
+ representing predicted quantities.
+ target_tensor: an N-d tensor of shape [batch, anchors, ...] representing
+ regression or classification targets.
+ ignore_nan_targets: whether to ignore nan targets in the loss computation.
+ E.g. can be used if the target tensor is missing groundtruth data that
+ shouldn't be factored into the loss.
+ losses_mask: A [batch] boolean tensor that indicates whether losses should
+ be applied to individual images in the batch. For elements that
+ are False, corresponding prediction, target, and weight tensors will not
+ contribute to loss computation. If None, no filtering will take place
+ prior to loss computation.
+ scope: Op scope name. Defaults to 'Loss' if None.
+ **params: Additional keyword arguments for specific implementations of
+ the Loss.
+
+ Returns:
+ loss: a tensor representing the value of the loss function.
+ """
+ with tf.name_scope(scope, 'Loss',
+ [prediction_tensor, target_tensor, params]) as scope:
+ if ignore_nan_targets:
+ target_tensor = tf.where(tf.is_nan(target_tensor),
+ prediction_tensor,
+ target_tensor)
+ if losses_mask is not None:
+ tensor_multiplier = self._get_loss_multiplier_for_tensor(
+ prediction_tensor,
+ losses_mask)
+ prediction_tensor *= tensor_multiplier
+ target_tensor *= tensor_multiplier
+
+ if 'weights' in params:
+ params['weights'] = tf.convert_to_tensor(params['weights'])
+ weights_multiplier = self._get_loss_multiplier_for_tensor(
+ params['weights'],
+ losses_mask)
+ params['weights'] *= weights_multiplier
+ return self._compute_loss(prediction_tensor, target_tensor, **params)
+
+ def _get_loss_multiplier_for_tensor(self, tensor, losses_mask):
+ loss_multiplier_shape = tf.stack([-1] + [1] * (len(tensor.shape) - 1))
+ return tf.cast(tf.reshape(losses_mask, loss_multiplier_shape), tf.float32)
+
+ @abc.abstractmethod
+ def _compute_loss(self, prediction_tensor, target_tensor, **params):
+ """Method to be overridden by implementations.
+
+ Args:
+ prediction_tensor: a tensor representing predicted quantities
+ target_tensor: a tensor representing regression or classification targets
+ **params: Additional keyword arguments for specific implementations of
+ the Loss.
+
+ Returns:
+ loss: an N-d tensor of shape [batch, anchors, ...] containing the loss per
+ anchor
+ """
+ pass
+
+
+class WeightedL2LocalizationLoss(Loss):
+ """L2 localization loss function with anchorwise output support.
+
+ Loss[b,a] = .5 * ||weights[b,a] * (prediction[b,a,:] - target[b,a,:])||^2
+ """
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the (encoded) predicted locations of objects.
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the regression targets
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ weighted_diff = (prediction_tensor - target_tensor) * tf.expand_dims(
+ weights, 2)
+ square_diff = 0.5 * tf.square(weighted_diff)
+ return tf.reduce_sum(square_diff, 2)
+
+
+class WeightedSmoothL1LocalizationLoss(Loss):
+ """Smooth L1 localization loss function aka Huber Loss..
+
+ The smooth L1_loss is defined elementwise as .5 x^2 if |x| <= delta and
+ delta * (|x|- 0.5*delta) otherwise, where x is the difference between
+ predictions and target.
+
+ See also Equation (3) in the Fast R-CNN paper by Ross Girshick (ICCV 2015)
+ """
+
+ def __init__(self, delta=1.0):
+ """Constructor.
+
+ Args:
+ delta: delta for smooth L1 loss.
+ """
+ super(WeightedSmoothL1LocalizationLoss, self).__init__()
+ self._delta = delta
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the (encoded) predicted locations of objects.
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ code_size] representing the regression targets
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ return tf.reduce_sum(tf.losses.huber_loss(
+ target_tensor,
+ prediction_tensor,
+ delta=self._delta,
+ weights=tf.expand_dims(weights, axis=2),
+ loss_collection=None,
+ reduction=tf.losses.Reduction.NONE
+ ), axis=2)
+
+
+class WeightedIOULocalizationLoss(Loss):
+ """IOU localization loss function.
+
+ Sums the IOU for corresponding pairs of predicted/groundtruth boxes
+ and for each pair assign a loss of 1 - IOU. We then compute a weighted
+ sum over all pairs which is returned as the total loss.
+ """
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors, 4]
+ representing the decoded predicted boxes
+ target_tensor: A float tensor of shape [batch_size, num_anchors, 4]
+ representing the decoded target boxes
+ weights: a float tensor of shape [batch_size, num_anchors]
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors] tensor
+ representing the value of the loss function.
+ """
+ predicted_boxes = box_list.BoxList(tf.reshape(prediction_tensor, [-1, 4]))
+ target_boxes = box_list.BoxList(tf.reshape(target_tensor, [-1, 4]))
+ per_anchor_iou_loss = 1.0 - box_list_ops.matched_iou(predicted_boxes,
+ target_boxes)
+ return tf.reshape(weights, [-1]) * per_anchor_iou_loss
+
+
+class WeightedSigmoidClassificationLoss(Loss):
+ """Sigmoid cross entropy classification loss function."""
+
+ def _compute_loss(self,
+ prediction_tensor,
+ target_tensor,
+ weights,
+ class_indices=None):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+ class_indices: (Optional) A 1-D integer tensor of class indices.
+ If provided, computes loss only for the specified class indices.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if class_indices is not None:
+ weights *= tf.reshape(
+ ops.indices_to_dense_vector(class_indices,
+ tf.shape(prediction_tensor)[2]),
+ [1, 1, -1])
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=target_tensor, logits=prediction_tensor))
+ return per_entry_cross_ent * weights
+
+
+class SigmoidFocalClassificationLoss(Loss):
+ """Sigmoid focal cross entropy loss.
+
+ Focal loss down-weights well classified examples and focusses on the hard
+ examples. See https://arxiv.org/pdf/1708.02002.pdf for the loss definition.
+ """
+
+ def __init__(self, gamma=2.0, alpha=0.25):
+ """Constructor.
+
+ Args:
+ gamma: exponent of the modulating factor (1 - p_t) ^ gamma.
+ alpha: optional alpha weighting factor to balance positives vs negatives.
+ """
+ super(SigmoidFocalClassificationLoss, self).__init__()
+ self._alpha = alpha
+ self._gamma = gamma
+
+ def _compute_loss(self,
+ prediction_tensor,
+ target_tensor,
+ weights,
+ class_indices=None):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+ class_indices: (Optional) A 1-D integer tensor of class indices.
+ If provided, computes loss only for the specified class indices.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if class_indices is not None:
+ weights *= tf.reshape(
+ ops.indices_to_dense_vector(class_indices,
+ tf.shape(prediction_tensor)[2]),
+ [1, 1, -1])
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=target_tensor, logits=prediction_tensor))
+ prediction_probabilities = tf.sigmoid(prediction_tensor)
+ p_t = ((target_tensor * prediction_probabilities) +
+ ((1 - target_tensor) * (1 - prediction_probabilities)))
+ modulating_factor = 1.0
+ if self._gamma:
+ modulating_factor = tf.pow(1.0 - p_t, self._gamma)
+ alpha_weight_factor = 1.0
+ if self._alpha is not None:
+ alpha_weight_factor = (target_tensor * self._alpha +
+ (1 - target_tensor) * (1 - self._alpha))
+ focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor *
+ per_entry_cross_ent)
+ return focal_cross_entropy_loss * weights
+
+
+class WeightedSoftmaxClassificationLoss(Loss):
+ """Softmax loss function."""
+
+ def __init__(self, logit_scale=1.0):
+ """Constructor.
+
+ Args:
+ logit_scale: When this value is high, the prediction is "diffused" and
+ when this value is low, the prediction is made peakier.
+ (default 1.0)
+
+ """
+ super(WeightedSoftmaxClassificationLoss, self).__init__()
+ self._logit_scale = logit_scale
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors]
+ representing the value of the loss function.
+ """
+ weights = tf.reduce_mean(weights, axis=2)
+ num_classes = prediction_tensor.get_shape().as_list()[-1]
+ prediction_tensor = tf.divide(
+ prediction_tensor, self._logit_scale, name='scale_logit')
+ per_row_cross_ent = (tf.nn.softmax_cross_entropy_with_logits(
+ labels=tf.reshape(target_tensor, [-1, num_classes]),
+ logits=tf.reshape(prediction_tensor, [-1, num_classes])))
+ return tf.reshape(per_row_cross_ent, tf.shape(weights)) * weights
+
+
+class WeightedSoftmaxClassificationAgainstLogitsLoss(Loss):
+ """Softmax loss function against logits.
+
+ Targets are expected to be provided in logits space instead of "one hot" or
+ "probability distribution" space.
+ """
+
+ def __init__(self, logit_scale=1.0):
+ """Constructor.
+
+ Args:
+ logit_scale: When this value is high, the target is "diffused" and
+ when this value is low, the target is made peakier.
+ (default 1.0)
+
+ """
+ super(WeightedSoftmaxClassificationAgainstLogitsLoss, self).__init__()
+ self._logit_scale = logit_scale
+
+ def _scale_and_softmax_logits(self, logits):
+ """Scale logits then apply softmax."""
+ scaled_logits = tf.divide(logits, self._logit_scale, name='scale_logits')
+ return tf.nn.softmax(scaled_logits, name='convert_scores')
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing logit classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors]
+ representing the value of the loss function.
+ """
+ weights = tf.reduce_mean(weights, axis=2)
+ num_classes = prediction_tensor.get_shape().as_list()[-1]
+ target_tensor = self._scale_and_softmax_logits(target_tensor)
+ prediction_tensor = tf.divide(prediction_tensor, self._logit_scale,
+ name='scale_logits')
+
+ per_row_cross_ent = (tf.nn.softmax_cross_entropy_with_logits(
+ labels=tf.reshape(target_tensor, [-1, num_classes]),
+ logits=tf.reshape(prediction_tensor, [-1, num_classes])))
+ return tf.reshape(per_row_cross_ent, tf.shape(weights)) * weights
+
+
+class BootstrappedSigmoidClassificationLoss(Loss):
+ """Bootstrapped sigmoid cross entropy classification loss function.
+
+ This loss uses a convex combination of training labels and the current model's
+ predictions as training targets in the classification loss. The idea is that
+ as the model improves over time, its predictions can be trusted more and we
+ can use these predictions to mitigate the damage of noisy/incorrect labels,
+ because incorrect labels are likely to be eventually highly inconsistent with
+ other stimuli predicted to have the same label by the model.
+
+ In "soft" bootstrapping, we use all predicted class probabilities, whereas in
+ "hard" bootstrapping, we use the single class favored by the model.
+
+ See also Training Deep Neural Networks On Noisy Labels with Bootstrapping by
+ Reed et al. (ICLR 2015).
+ """
+
+ def __init__(self, alpha, bootstrap_type='soft'):
+ """Constructor.
+
+ Args:
+ alpha: a float32 scalar tensor between 0 and 1 representing interpolation
+ weight
+ bootstrap_type: set to either 'hard' or 'soft' (default)
+
+ Raises:
+ ValueError: if bootstrap_type is not either 'hard' or 'soft'
+ """
+ super(BootstrappedSigmoidClassificationLoss, self).__init__()
+ if bootstrap_type != 'hard' and bootstrap_type != 'soft':
+ raise ValueError('Unrecognized bootstrap_type: must be one of '
+ '\'hard\' or \'soft.\'')
+ self._alpha = alpha
+ self._bootstrap_type = bootstrap_type
+
+ def _compute_loss(self, prediction_tensor, target_tensor, weights):
+ """Compute loss function.
+
+ Args:
+ prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing the predicted logits for each class
+ target_tensor: A float tensor of shape [batch_size, num_anchors,
+ num_classes] representing one-hot encoded classification targets
+ weights: a float tensor of shape, either [batch_size, num_anchors,
+ num_classes] or [batch_size, num_anchors, 1]. If the shape is
+ [batch_size, num_anchors, 1], all the classses are equally weighted.
+
+ Returns:
+ loss: a float tensor of shape [batch_size, num_anchors, num_classes]
+ representing the value of the loss function.
+ """
+ if self._bootstrap_type == 'soft':
+ bootstrap_target_tensor = self._alpha * target_tensor + (
+ 1.0 - self._alpha) * tf.sigmoid(prediction_tensor)
+ else:
+ bootstrap_target_tensor = self._alpha * target_tensor + (
+ 1.0 - self._alpha) * tf.cast(
+ tf.sigmoid(prediction_tensor) > 0.5, tf.float32)
+ per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits(
+ labels=bootstrap_target_tensor, logits=prediction_tensor))
+ return per_entry_cross_ent * weights
+
+
+class HardExampleMiner(object):
+ """Hard example mining for regions in a list of images.
+
+ Implements hard example mining to select a subset of regions to be
+ back-propagated. For each image, selects the regions with highest losses,
+ subject to the condition that a newly selected region cannot have
+ an IOU > iou_threshold with any of the previously selected regions.
+ This can be achieved by re-using a greedy non-maximum suppression algorithm.
+ A constraint on the number of negatives mined per positive region can also be
+ enforced.
+
+ Reference papers: "Training Region-based Object Detectors with Online
+ Hard Example Mining" (CVPR 2016) by Srivastava et al., and
+ "SSD: Single Shot MultiBox Detector" (ECCV 2016) by Liu et al.
+ """
+
+ def __init__(self,
+ num_hard_examples=64,
+ iou_threshold=0.7,
+ loss_type='both',
+ cls_loss_weight=0.05,
+ loc_loss_weight=0.06,
+ max_negatives_per_positive=None,
+ min_negatives_per_image=0):
+ """Constructor.
+
+ The hard example mining implemented by this class can replicate the behavior
+ in the two aforementioned papers (Srivastava et al., and Liu et al).
+ To replicate the A2 paper (Srivastava et al), num_hard_examples is set
+ to a fixed parameter (64 by default) and iou_threshold is set to .7 for
+ running non-max-suppression the predicted boxes prior to hard mining.
+ In order to replicate the SSD paper (Liu et al), num_hard_examples should
+ be set to None, max_negatives_per_positive should be 3 and iou_threshold
+ should be 1.0 (in order to effectively turn off NMS).
+
+ Args:
+ num_hard_examples: maximum number of hard examples to be
+ selected per image (prior to enforcing max negative to positive ratio
+ constraint). If set to None, all examples obtained after NMS are
+ considered.
+ iou_threshold: minimum intersection over union for an example
+ to be discarded during NMS.
+ loss_type: use only classification losses ('cls', default),
+ localization losses ('loc') or both losses ('both').
+ In the last case, cls_loss_weight and loc_loss_weight are used to
+ compute weighted sum of the two losses.
+ cls_loss_weight: weight for classification loss.
+ loc_loss_weight: weight for location loss.
+ max_negatives_per_positive: maximum number of negatives to retain for
+ each positive anchor. By default, num_negatives_per_positive is None,
+ which means that we do not enforce a prespecified negative:positive
+ ratio. Note also that num_negatives_per_positives can be a float
+ (and will be converted to be a float even if it is passed in otherwise).
+ min_negatives_per_image: minimum number of negative anchors to sample for
+ a given image. Setting this to a positive number allows sampling
+ negatives in an image without any positive anchors and thus not biased
+ towards at least one detection per image.
+ """
+ self._num_hard_examples = num_hard_examples
+ self._iou_threshold = iou_threshold
+ self._loss_type = loss_type
+ self._cls_loss_weight = cls_loss_weight
+ self._loc_loss_weight = loc_loss_weight
+ self._max_negatives_per_positive = max_negatives_per_positive
+ self._min_negatives_per_image = min_negatives_per_image
+ if self._max_negatives_per_positive is not None:
+ self._max_negatives_per_positive = float(self._max_negatives_per_positive)
+ self._num_positives_list = None
+ self._num_negatives_list = None
+
+ def __call__(self,
+ location_losses,
+ cls_losses,
+ decoded_boxlist_list,
+ match_list=None):
+ """Computes localization and classification losses after hard mining.
+
+ Args:
+ location_losses: a float tensor of shape [num_images, num_anchors]
+ representing anchorwise localization losses.
+ cls_losses: a float tensor of shape [num_images, num_anchors]
+ representing anchorwise classification losses.
+ decoded_boxlist_list: a list of decoded BoxList representing location
+ predictions for each image.
+ match_list: an optional list of matcher.Match objects encoding the match
+ between anchors and groundtruth boxes for each image of the batch,
+ with rows of the Match objects corresponding to groundtruth boxes
+ and columns corresponding to anchors. Match objects in match_list are
+ used to reference which anchors are positive, negative or ignored. If
+ self._max_negatives_per_positive exists, these are then used to enforce
+ a prespecified negative to positive ratio.
+
+ Returns:
+ mined_location_loss: a float scalar with sum of localization losses from
+ selected hard examples.
+ mined_cls_loss: a float scalar with sum of classification losses from
+ selected hard examples.
+ Raises:
+ ValueError: if location_losses, cls_losses and decoded_boxlist_list do
+ not have compatible shapes (i.e., they must correspond to the same
+ number of images).
+ ValueError: if match_list is specified but its length does not match
+ len(decoded_boxlist_list).
+ """
+ mined_location_losses = []
+ mined_cls_losses = []
+ location_losses = tf.unstack(location_losses)
+ cls_losses = tf.unstack(cls_losses)
+ num_images = len(decoded_boxlist_list)
+ if not match_list:
+ match_list = num_images * [None]
+ if not len(location_losses) == len(decoded_boxlist_list) == len(cls_losses):
+ raise ValueError('location_losses, cls_losses and decoded_boxlist_list '
+ 'do not have compatible shapes.')
+ if not isinstance(match_list, list):
+ raise ValueError('match_list must be a list.')
+ if len(match_list) != len(decoded_boxlist_list):
+ raise ValueError('match_list must either be None or have '
+ 'length=len(decoded_boxlist_list).')
+ num_positives_list = []
+ num_negatives_list = []
+ for ind, detection_boxlist in enumerate(decoded_boxlist_list):
+ box_locations = detection_boxlist.get()
+ match = match_list[ind]
+ image_losses = cls_losses[ind]
+ if self._loss_type == 'loc':
+ image_losses = location_losses[ind]
+ elif self._loss_type == 'both':
+ image_losses *= self._cls_loss_weight
+ image_losses += location_losses[ind] * self._loc_loss_weight
+ if self._num_hard_examples is not None:
+ num_hard_examples = self._num_hard_examples
+ else:
+ num_hard_examples = detection_boxlist.num_boxes()
+ selected_indices = tf.image.non_max_suppression(
+ box_locations, image_losses, num_hard_examples, self._iou_threshold)
+ if self._max_negatives_per_positive is not None and match:
+ (selected_indices, num_positives,
+ num_negatives) = self._subsample_selection_to_desired_neg_pos_ratio(
+ selected_indices, match, self._max_negatives_per_positive,
+ self._min_negatives_per_image)
+ num_positives_list.append(num_positives)
+ num_negatives_list.append(num_negatives)
+ mined_location_losses.append(
+ tf.reduce_sum(tf.gather(location_losses[ind], selected_indices)))
+ mined_cls_losses.append(
+ tf.reduce_sum(tf.gather(cls_losses[ind], selected_indices)))
+ location_loss = tf.reduce_sum(tf.stack(mined_location_losses))
+ cls_loss = tf.reduce_sum(tf.stack(mined_cls_losses))
+ if match and self._max_negatives_per_positive:
+ self._num_positives_list = num_positives_list
+ self._num_negatives_list = num_negatives_list
+ return (location_loss, cls_loss)
+
+ def summarize(self):
+ """Summarize the number of positives and negatives after mining."""
+ if self._num_positives_list and self._num_negatives_list:
+ avg_num_positives = tf.reduce_mean(
+ tf.cast(self._num_positives_list, dtype=tf.float32))
+ avg_num_negatives = tf.reduce_mean(
+ tf.cast(self._num_negatives_list, dtype=tf.float32))
+ tf.summary.scalar('HardExampleMiner/NumPositives', avg_num_positives)
+ tf.summary.scalar('HardExampleMiner/NumNegatives', avg_num_negatives)
+
+ def _subsample_selection_to_desired_neg_pos_ratio(self,
+ indices,
+ match,
+ max_negatives_per_positive,
+ min_negatives_per_image=0):
+ """Subsample a collection of selected indices to a desired neg:pos ratio.
+
+ This function takes a subset of M indices (indexing into a large anchor
+ collection of N anchors where M=0,
+ meaning that column i is matched with row match_results[i].
+ (2) match_results[i]=-1, meaning that column i is not matched.
+ (3) match_results[i]=-2, meaning that column i is ignored.
+ use_matmul_gather: Use matrix multiplication based gather instead of
+ standard tf.gather. (Default: False).
+
+ Raises:
+ ValueError: if match_results does not have rank 1 or is not an
+ integer int32 scalar tensor
+ """
+ if match_results.shape.ndims != 1:
+ raise ValueError('match_results should have rank 1')
+ if match_results.dtype != tf.int32:
+ raise ValueError('match_results should be an int32 or int64 scalar '
+ 'tensor')
+ self._match_results = match_results
+ self._gather_op = tf.gather
+ if use_matmul_gather:
+ self._gather_op = ops.matmul_gather_on_zeroth_axis
+
+ @property
+ def match_results(self):
+ """The accessor for match results.
+
+ Returns:
+ the tensor which encodes the match results.
+ """
+ return self._match_results
+
+ def matched_column_indices(self):
+ """Returns column indices that match to some row.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.greater(self._match_results, -1)))
+
+ def matched_column_indicator(self):
+ """Returns column indices that are matched.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return tf.greater_equal(self._match_results, 0)
+
+ def num_matched_columns(self):
+ """Returns number (int32 scalar tensor) of matched columns."""
+ return tf.size(self.matched_column_indices())
+
+ def unmatched_column_indices(self):
+ """Returns column indices that do not match any row.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.equal(self._match_results, -1)))
+
+ def unmatched_column_indicator(self):
+ """Returns column indices that are unmatched.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return tf.equal(self._match_results, -1)
+
+ def num_unmatched_columns(self):
+ """Returns number (int32 scalar tensor) of unmatched columns."""
+ return tf.size(self.unmatched_column_indices())
+
+ def ignored_column_indices(self):
+ """Returns column indices that are ignored (neither Matched nor Unmatched).
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(self.ignored_column_indicator()))
+
+ def ignored_column_indicator(self):
+ """Returns boolean column indicator where True means the colum is ignored.
+
+ Returns:
+ column_indicator: boolean vector which is True for all ignored column
+ indices.
+ """
+ return tf.equal(self._match_results, -2)
+
+ def num_ignored_columns(self):
+ """Returns number (int32 scalar tensor) of matched columns."""
+ return tf.size(self.ignored_column_indices())
+
+ def unmatched_or_ignored_column_indices(self):
+ """Returns column indices that are unmatched or ignored.
+
+ The indices returned by this op are always sorted in increasing order.
+
+ Returns:
+ column_indices: int32 tensor of shape [K] with column indices.
+ """
+ return self._reshape_and_cast(tf.where(tf.greater(0, self._match_results)))
+
+ def matched_row_indices(self):
+ """Returns row indices that match some column.
+
+ The indices returned by this op are ordered so as to be in correspondence
+ with the output of matched_column_indicator(). For example if
+ self.matched_column_indicator() is [0,2], and self.matched_row_indices() is
+ [7, 3], then we know that column 0 was matched to row 7 and column 2 was
+ matched to row 3.
+
+ Returns:
+ row_indices: int32 tensor of shape [K] with row indices.
+ """
+ return self._reshape_and_cast(
+ self._gather_op(tf.cast(self._match_results, dtype=tf.float32),
+ self.matched_column_indices()))
+
+ def num_matched_rows(self):
+ """Returns number (int32 scalar tensor) of matched rows."""
+ unique_rows, _ = tf.unique(self.matched_row_indices())
+ return tf.size(unique_rows)
+
+ def _reshape_and_cast(self, t):
+ return tf.cast(tf.reshape(t, [-1]), tf.int32)
+
+ def gather_based_on_match(self, input_tensor, unmatched_value,
+ ignored_value):
+ """Gathers elements from `input_tensor` based on match results.
+
+ For columns that are matched to a row, gathered_tensor[col] is set to
+ input_tensor[match_results[col]]. For columns that are unmatched,
+ gathered_tensor[col] is set to unmatched_value. Finally, for columns that
+ are ignored gathered_tensor[col] is set to ignored_value.
+
+ Note that the input_tensor.shape[1:] must match with unmatched_value.shape
+ and ignored_value.shape
+
+ Args:
+ input_tensor: Tensor to gather values from.
+ unmatched_value: Constant tensor value for unmatched columns.
+ ignored_value: Constant tensor value for ignored columns.
+
+ Returns:
+ gathered_tensor: A tensor containing values gathered from input_tensor.
+ The shape of the gathered tensor is [match_results.shape[0]] +
+ input_tensor.shape[1:].
+ """
+ input_tensor = tf.concat(
+ [tf.stack([ignored_value, unmatched_value]),
+ input_tensor],
+ axis=0)
+ gather_indices = tf.maximum(self.match_results + 2, 0)
+ gathered_tensor = self._gather_op(input_tensor, gather_indices)
+ return gathered_tensor
+
+
+class Matcher(six.with_metaclass(abc.ABCMeta, object)):
+ """Abstract base class for matcher.
+ """
+
+ def __init__(self, use_matmul_gather=False):
+ """Constructs a Matcher.
+
+ Args:
+ use_matmul_gather: Force constructed match objects to use matrix
+ multiplication based gather instead of standard tf.gather.
+ (Default: False).
+ """
+ self._use_matmul_gather = use_matmul_gather
+
+ def match(self, similarity_matrix, valid_rows=None, scope=None):
+ """Computes matches among row and column indices and returns the result.
+
+ Computes matches among the row and column indices based on the similarity
+ matrix and optional arguments.
+
+ Args:
+ similarity_matrix: Float tensor of shape [N, M] with pairwise similarity
+ where higher value means more similar.
+ valid_rows: A boolean tensor of shape [N] indicating the rows that are
+ valid for matching.
+ scope: Op scope name. Defaults to 'Match' if None.
+
+ Returns:
+ A Match object with the results of matching.
+ """
+ with tf.name_scope(scope, 'Match') as scope:
+ if valid_rows is None:
+ valid_rows = tf.ones(tf.shape(similarity_matrix)[0], dtype=tf.bool)
+ return Match(self._match(similarity_matrix, valid_rows),
+ self._use_matmul_gather)
+
+ @abc.abstractmethod
+ def _match(self, similarity_matrix, valid_rows):
+ """Method to be overridden by implementations.
+
+ Args:
+ similarity_matrix: Float tensor of shape [N, M] with pairwise similarity
+ where higher value means more similar.
+ valid_rows: A boolean tensor of shape [N] indicating the rows that are
+ valid for matching.
+ Returns:
+ match_results: Integer tensor of shape [M]: match_results[i]>=0 means
+ that column i is matched to row match_results[i], match_results[i]=-1
+ means that the column is not matched. match_results[i]=-2 means that
+ the column is ignored (usually this happens when there is a very weak
+ match which one neither wants as positive nor negative example).
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/matcher_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/matcher_test.py
new file mode 100644
index 00000000..1ed32167
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/matcher_test.py
@@ -0,0 +1,197 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.matcher."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import matcher
+
+
+class MatchTest(tf.test.TestCase):
+
+ def test_get_correct_matched_columnIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [0, 1, 3, 5]
+ matched_column_indices = match.matched_column_indices()
+ self.assertEqual(matched_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ matched_column_indices = sess.run(matched_column_indices)
+ self.assertAllEqual(matched_column_indices, expected_column_indices)
+
+ def test_get_correct_counts(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 1, -2])
+ match = matcher.Match(match_results)
+ exp_num_matched_columns = 4
+ exp_num_unmatched_columns = 2
+ exp_num_ignored_columns = 1
+ exp_num_matched_rows = 3
+ num_matched_columns = match.num_matched_columns()
+ num_unmatched_columns = match.num_unmatched_columns()
+ num_ignored_columns = match.num_ignored_columns()
+ num_matched_rows = match.num_matched_rows()
+ self.assertEqual(num_matched_columns.dtype, tf.int32)
+ self.assertEqual(num_unmatched_columns.dtype, tf.int32)
+ self.assertEqual(num_ignored_columns.dtype, tf.int32)
+ self.assertEqual(num_matched_rows.dtype, tf.int32)
+ with self.test_session() as sess:
+ (num_matched_columns_out, num_unmatched_columns_out,
+ num_ignored_columns_out, num_matched_rows_out) = sess.run(
+ [num_matched_columns, num_unmatched_columns, num_ignored_columns,
+ num_matched_rows])
+ self.assertAllEqual(num_matched_columns_out, exp_num_matched_columns)
+ self.assertAllEqual(num_unmatched_columns_out, exp_num_unmatched_columns)
+ self.assertAllEqual(num_ignored_columns_out, exp_num_ignored_columns)
+ self.assertAllEqual(num_matched_rows_out, exp_num_matched_rows)
+
+ def testGetCorrectUnmatchedColumnIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [2, 4]
+ unmatched_column_indices = match.unmatched_column_indices()
+ self.assertEqual(unmatched_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ unmatched_column_indices = sess.run(unmatched_column_indices)
+ self.assertAllEqual(unmatched_column_indices, expected_column_indices)
+
+ def testGetCorrectMatchedRowIndices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_row_indices = [3, 1, 0, 5]
+ matched_row_indices = match.matched_row_indices()
+ self.assertEqual(matched_row_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ matched_row_inds = sess.run(matched_row_indices)
+ self.assertAllEqual(matched_row_inds, expected_row_indices)
+
+ def test_get_correct_ignored_column_indices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [6]
+ ignored_column_indices = match.ignored_column_indices()
+ self.assertEqual(ignored_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ ignored_column_indices = sess.run(ignored_column_indices)
+ self.assertAllEqual(ignored_column_indices, expected_column_indices)
+
+ def test_get_correct_matched_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [True, True, False, True, False, True, False]
+ matched_column_indicator = match.matched_column_indicator()
+ self.assertEqual(matched_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ matched_column_indicator = sess.run(matched_column_indicator)
+ self.assertAllEqual(matched_column_indicator, expected_column_indicator)
+
+ def test_get_correct_unmatched_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [False, False, True, False, True, False, False]
+ unmatched_column_indicator = match.unmatched_column_indicator()
+ self.assertEqual(unmatched_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ unmatched_column_indicator = sess.run(unmatched_column_indicator)
+ self.assertAllEqual(unmatched_column_indicator, expected_column_indicator)
+
+ def test_get_correct_ignored_column_indicator(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indicator = [False, False, False, False, False, False, True]
+ ignored_column_indicator = match.ignored_column_indicator()
+ self.assertEqual(ignored_column_indicator.dtype, tf.bool)
+ with self.test_session() as sess:
+ ignored_column_indicator = sess.run(ignored_column_indicator)
+ self.assertAllEqual(ignored_column_indicator, expected_column_indicator)
+
+ def test_get_correct_unmatched_ignored_column_indices(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ match = matcher.Match(match_results)
+ expected_column_indices = [2, 4, 6]
+ unmatched_ignored_column_indices = (match.
+ unmatched_or_ignored_column_indices())
+ self.assertEqual(unmatched_ignored_column_indices.dtype, tf.int32)
+ with self.test_session() as sess:
+ unmatched_ignored_column_indices = sess.run(
+ unmatched_ignored_column_indices)
+ self.assertAllEqual(unmatched_ignored_column_indices,
+ expected_column_indices)
+
+ def test_all_columns_accounted_for(self):
+ # Note: deliberately setting to small number so not always
+ # all possibilities appear (matched, unmatched, ignored)
+ num_matches = 10
+ match_results = tf.random_uniform(
+ [num_matches], minval=-2, maxval=5, dtype=tf.int32)
+ match = matcher.Match(match_results)
+ matched_column_indices = match.matched_column_indices()
+ unmatched_column_indices = match.unmatched_column_indices()
+ ignored_column_indices = match.ignored_column_indices()
+ with self.test_session() as sess:
+ matched, unmatched, ignored = sess.run([
+ matched_column_indices, unmatched_column_indices,
+ ignored_column_indices
+ ])
+ all_indices = np.hstack((matched, unmatched, ignored))
+ all_indices_sorted = np.sort(all_indices)
+ self.assertAllEqual(all_indices_sorted,
+ np.arange(num_matches, dtype=np.int32))
+
+ def test_scalar_gather_based_on_match(self):
+ match_results = tf.constant([3, 1, -1, 0, -1, 5, -2])
+ input_tensor = tf.constant([0, 1, 2, 3, 4, 5, 6, 7], dtype=tf.float32)
+ expected_gathered_tensor = [3, 1, 100, 0, 100, 5, 200]
+ match = matcher.Match(match_results)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=100.,
+ ignored_value=200.)
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session():
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+ def test_multidimensional_gather_based_on_match(self):
+ match_results = tf.constant([1, -1, -2])
+ input_tensor = tf.constant([[0, 0.5, 0, 0.5], [0, 0, 0.5, 0.5]],
+ dtype=tf.float32)
+ expected_gathered_tensor = [[0, 0, 0.5, 0.5], [0, 0, 0, 0], [0, 0, 0, 0]]
+ match = matcher.Match(match_results)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session():
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+ def test_multidimensional_gather_based_on_match_with_matmul_gather_op(self):
+ match_results = tf.constant([1, -1, -2])
+ input_tensor = tf.constant([[0, 0.5, 0, 0.5], [0, 0, 0.5, 0.5]],
+ dtype=tf.float32)
+ expected_gathered_tensor = [[0, 0, 0.5, 0.5], [0, 0, 0, 0], [0, 0, 0, 0]]
+ match = matcher.Match(match_results, use_matmul_gather=True)
+ gathered_tensor = match.gather_based_on_match(input_tensor,
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ self.assertEqual(gathered_tensor.dtype, tf.float32)
+ with self.test_session() as sess:
+ self.assertTrue(
+ all([op.name is not 'Gather' for op in sess.graph.get_operations()]))
+ gathered_tensor_out = gathered_tensor.eval()
+ self.assertAllEqual(expected_gathered_tensor, gathered_tensor_out)
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler.py
new file mode 100644
index 00000000..7628c8df
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler.py
@@ -0,0 +1,94 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base minibatch sampler module.
+
+The job of the minibatch_sampler is to subsample a minibatch based on some
+criterion.
+
+The main function call is:
+ subsample(indicator, batch_size, **params).
+Indicator is a 1d boolean tensor where True denotes which examples can be
+sampled. It returns a boolean indicator where True denotes an example has been
+sampled..
+
+Subclasses should implement the Subsample function and can make use of the
+@staticmethod SubsampleIndicator.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+import tensorflow as tf
+
+from object_detection.utils import ops
+
+
+class MinibatchSampler(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for subsampling minibatches."""
+
+ def __init__(self):
+ """Constructs a minibatch sampler."""
+ pass
+
+ @abstractmethod
+ def subsample(self, indicator, batch_size, **params):
+ """Returns subsample of entries in indicator.
+
+ Args:
+ indicator: boolean tensor of shape [N] whose True entries can be sampled.
+ batch_size: desired batch size.
+ **params: additional keyword arguments for specific implementations of
+ the MinibatchSampler.
+
+ Returns:
+ sample_indicator: boolean tensor of shape [N] whose True entries have been
+ sampled. If sum(indicator) >= batch_size, sum(is_sampled) = batch_size
+ """
+ pass
+
+ @staticmethod
+ def subsample_indicator(indicator, num_samples):
+ """Subsample indicator vector.
+
+ Given a boolean indicator vector with M elements set to `True`, the function
+ assigns all but `num_samples` of these previously `True` elements to
+ `False`. If `num_samples` is greater than M, the original indicator vector
+ is returned.
+
+ Args:
+ indicator: a 1-dimensional boolean tensor indicating which elements
+ are allowed to be sampled and which are not.
+ num_samples: int32 scalar tensor
+
+ Returns:
+ a boolean tensor with the same shape as input (indicator) tensor
+ """
+ indices = tf.where(indicator)
+ indices = tf.random_shuffle(indices)
+ indices = tf.reshape(indices, [-1])
+
+ num_samples = tf.minimum(tf.size(indices), num_samples)
+ selected_indices = tf.slice(indices, [0], tf.reshape(num_samples, [1]))
+
+ selected_indicator = ops.indices_to_dense_vector(selected_indices,
+ tf.shape(indicator)[0])
+
+ return tf.equal(selected_indicator, 1)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler_test.py
new file mode 100644
index 00000000..7420ae5d
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/minibatch_sampler_test.py
@@ -0,0 +1,82 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for google3.research.vale.object_detection.minibatch_sampler."""
+
+import numpy as np
+import tensorflow as tf
+
+from object_detection.core import minibatch_sampler
+
+
+class MinibatchSamplerTest(tf.test.TestCase):
+
+ def test_subsample_indicator_when_more_true_elements_than_num_samples(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 3)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples)
+ self.assertTrue(np.sum(samples_out), 3)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_when_more_true_elements_than_num_samples_no_shape(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.placeholder(tf.bool)
+ feed_dict = {indicator: np_indicator}
+
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 3)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples, feed_dict=feed_dict)
+ self.assertTrue(np.sum(samples_out), 3)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_indicator_when_less_true_elements_than_num_samples(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 5)
+ with self.test_session() as sess:
+ samples_out = sess.run(samples)
+ self.assertTrue(np.sum(samples_out), 4)
+ self.assertAllEqual(samples_out,
+ np.logical_and(samples_out, np_indicator))
+
+ def test_subsample_indicator_when_num_samples_is_zero(self):
+ np_indicator = [True, False, True, False, True, True, False]
+ indicator = tf.constant(np_indicator)
+ samples_none = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator, 0)
+ with self.test_session() as sess:
+ samples_none_out = sess.run(samples_none)
+ self.assertAllEqual(
+ np.zeros_like(samples_none_out, dtype=bool),
+ samples_none_out)
+
+ def test_subsample_indicator_when_indicator_all_false(self):
+ indicator_empty = tf.zeros([0], dtype=tf.bool)
+ samples_empty = minibatch_sampler.MinibatchSampler.subsample_indicator(
+ indicator_empty, 4)
+ with self.test_session() as sess:
+ samples_empty_out = sess.run(samples_empty)
+ self.assertEqual(0, samples_empty_out.size)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/model.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/model.py
new file mode 100644
index 00000000..b04d6250
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/model.py
@@ -0,0 +1,375 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Abstract detection model.
+
+This file defines a generic base class for detection models. Programs that are
+designed to work with arbitrary detection models should only depend on this
+class. We intend for the functions in this class to follow tensor-in/tensor-out
+design, thus all functions have tensors or lists/dictionaries holding tensors as
+inputs and outputs.
+
+Abstractly, detection models predict output tensors given input images
+which can be passed to a loss function at training time or passed to a
+postprocessing function at eval time. The computation graphs at a high level
+consequently look as follows:
+
+Training time:
+inputs (images tensor) -> preprocess -> predict -> loss -> outputs (loss tensor)
+
+Evaluation time:
+inputs (images tensor) -> preprocess -> predict -> postprocess
+ -> outputs (boxes tensor, scores tensor, classes tensor, num_detections tensor)
+
+DetectionModels must thus implement four functions (1) preprocess, (2) predict,
+(3) postprocess and (4) loss. DetectionModels should make no assumptions about
+the input size or aspect ratio --- they are responsible for doing any
+resize/reshaping necessary (see docstring for the preprocess function).
+Output classes are always integers in the range [0, num_classes). Any mapping
+of these integers to semantic labels is to be handled outside of this class.
+
+Images are resized in the `preprocess` method. All of `preprocess`, `predict`,
+and `postprocess` should be reentrant.
+
+The `preprocess` method runs `image_resizer_fn` that returns resized_images and
+`true_image_shapes`. Since `image_resizer_fn` can pad the images with zeros,
+true_image_shapes indicate the slices that contain the image without padding.
+This is useful for padding images to be a fixed size for batching.
+
+The `postprocess` method uses the true image shapes to clip predictions that lie
+outside of images.
+
+By default, DetectionModels produce bounding box detections; However, we support
+a handful of auxiliary annotations associated with each bounding box, namely,
+instance masks and keypoints.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import abc
+import six
+import tensorflow as tf
+
+from object_detection.core import standard_fields as fields
+
+
+# If using a new enough version of TensorFlow, detection models should be a
+# tf module or keras model for tracking.
+try:
+ _BaseClass = tf.Module
+except AttributeError:
+ _BaseClass = object
+
+
+class DetectionModel(six.with_metaclass(abc.ABCMeta, _BaseClass)):
+ """Abstract base class for detection models.
+
+ Extends tf.Module to guarantee variable tracking.
+ """
+
+ def __init__(self, num_classes):
+ """Constructor.
+
+ Args:
+ num_classes: number of classes. Note that num_classes *does not* include
+ background categories that might be implicitly predicted in various
+ implementations.
+ """
+ self._num_classes = num_classes
+ self._groundtruth_lists = {}
+
+ @property
+ def num_classes(self):
+ return self._num_classes
+
+ def groundtruth_lists(self, field):
+ """Access list of groundtruth tensors.
+
+ Args:
+ field: a string key, options are
+ fields.BoxListFields.{boxes,classes,masks,keypoints} or
+ fields.InputDataFields.is_annotated.
+
+ Returns:
+ a list of tensors holding groundtruth information (see also
+ provide_groundtruth function below), with one entry for each image in the
+ batch.
+ Raises:
+ RuntimeError: if the field has not been provided via provide_groundtruth.
+ """
+ if field not in self._groundtruth_lists:
+ raise RuntimeError('Groundtruth tensor {} has not been provided'.format(
+ field))
+ return self._groundtruth_lists[field]
+
+ def groundtruth_has_field(self, field):
+ """Determines whether the groundtruth includes the given field.
+
+ Args:
+ field: a string key, options are
+ fields.BoxListFields.{boxes,classes,masks,keypoints} or
+ fields.InputDataFields.is_annotated.
+
+ Returns:
+ True if the groundtruth includes the given field, False otherwise.
+ """
+ return field in self._groundtruth_lists
+
+ @abc.abstractmethod
+ def preprocess(self, inputs):
+ """Input preprocessing.
+
+ To be overridden by implementations.
+
+ This function is responsible for any scaling/shifting of input values that
+ is necessary prior to running the detector on an input image.
+ It is also responsible for any resizing, padding that might be necessary
+ as images are assumed to arrive in arbitrary sizes. While this function
+ could conceivably be part of the predict method (below), it is often
+ convenient to keep these separate --- for example, we may want to preprocess
+ on one device, place onto a queue, and let another device (e.g., the GPU)
+ handle prediction.
+
+ A few important notes about the preprocess function:
+ + We assume that this operation does not have any trainable variables nor
+ does it affect the groundtruth annotations in any way (thus data
+ augmentation operations such as random cropping should be performed
+ externally).
+ + There is no assumption that the batchsize in this function is the same as
+ the batch size in the predict function. In fact, we recommend calling the
+ preprocess function prior to calling any batching operations (which should
+ happen outside of the model) and thus assuming that batch sizes are equal
+ to 1 in the preprocess function.
+ + There is also no explicit assumption that the output resolutions
+ must be fixed across inputs --- this is to support "fully convolutional"
+ settings in which input images can have different shapes/resolutions.
+
+ Args:
+ inputs: a [batch, height_in, width_in, channels] float32 tensor
+ representing a batch of images with values between 0 and 255.0.
+
+ Returns:
+ preprocessed_inputs: a [batch, height_out, width_out, channels] float32
+ tensor representing a batch of images.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+ """
+ pass
+
+ @abc.abstractmethod
+ def predict(self, preprocessed_inputs, true_image_shapes):
+ """Predict prediction tensors from inputs tensor.
+
+ Outputs of this function can be passed to loss or postprocess functions.
+
+ Args:
+ preprocessed_inputs: a [batch, height, width, channels] float32 tensor
+ representing a batch of images.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+
+ Returns:
+ prediction_dict: a dictionary holding prediction tensors to be
+ passed to the Loss or Postprocess functions.
+ """
+ pass
+
+ @abc.abstractmethod
+ def postprocess(self, prediction_dict, true_image_shapes, **params):
+ """Convert predicted output tensors to final detections.
+
+ This stage typically performs a few things such as
+ * Non-Max Suppression to remove overlapping detection boxes.
+ * Score conversion and background class removal.
+
+ Outputs adhere to the following conventions:
+ * Classes are integers in [0, num_classes); background classes are removed
+ and the first non-background class is mapped to 0. If the model produces
+ class-agnostic detections, then no output is produced for classes.
+ * Boxes are to be interpreted as being in [y_min, x_min, y_max, x_max]
+ format and normalized relative to the image window.
+ * `num_detections` is provided for settings where detections are padded to a
+ fixed number of boxes.
+ * We do not specifically assume any kind of probabilistic interpretation
+ of the scores --- the only important thing is their relative ordering.
+ Thus implementations of the postprocess function are free to output
+ logits, probabilities, calibrated probabilities, or anything else.
+
+ Args:
+ prediction_dict: a dictionary holding prediction tensors.
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+ **params: Additional keyword arguments for specific implementations of
+ DetectionModel.
+
+ Returns:
+ detections: a dictionary containing the following fields
+ detection_boxes: [batch, max_detections, 4]
+ detection_scores: [batch, max_detections]
+ detection_classes: [batch, max_detections]
+ (If a model is producing class-agnostic detections, this field may be
+ missing)
+ instance_masks: [batch, max_detections, image_height, image_width]
+ (optional)
+ keypoints: [batch, max_detections, num_keypoints, 2] (optional)
+ num_detections: [batch]
+
+ In addition to the above fields this stage also outputs the following
+ raw tensors:
+
+ raw_detection_boxes: [batch, total_detections, 4] tensor containing
+ all detection boxes from `prediction_dict` in the format
+ [ymin, xmin, ymax, xmax] and normalized co-ordinates.
+ raw_detection_scores: [batch, total_detections,
+ num_classes_with_background] tensor of class score logits for
+ raw detection boxes.
+ """
+ pass
+
+ @abc.abstractmethod
+ def loss(self, prediction_dict, true_image_shapes):
+ """Compute scalar loss tensors with respect to provided groundtruth.
+
+ Calling this function requires that groundtruth tensors have been
+ provided via the provide_groundtruth function.
+
+ Args:
+ prediction_dict: a dictionary holding predicted tensors
+ true_image_shapes: int32 tensor of shape [batch, 3] where each row is
+ of the form [height, width, channels] indicating the shapes
+ of true images in the resized images, as resized images can be padded
+ with zeros.
+
+ Returns:
+ a dictionary mapping strings (loss names) to scalar tensors representing
+ loss values.
+ """
+ pass
+
+ def provide_groundtruth(self,
+ groundtruth_boxes_list,
+ groundtruth_classes_list,
+ groundtruth_masks_list=None,
+ groundtruth_keypoints_list=None,
+ groundtruth_weights_list=None,
+ groundtruth_confidences_list=None,
+ groundtruth_is_crowd_list=None,
+ is_annotated_list=None):
+ """Provide groundtruth tensors.
+
+ Args:
+ groundtruth_boxes_list: a list of 2-D tf.float32 tensors of shape
+ [num_boxes, 4] containing coordinates of the groundtruth boxes.
+ Groundtruth boxes are provided in [y_min, x_min, y_max, x_max]
+ format and assumed to be normalized and clipped
+ relative to the image window with y_min <= y_max and x_min <= x_max.
+ groundtruth_classes_list: a list of 2-D tf.float32 one-hot (or k-hot)
+ tensors of shape [num_boxes, num_classes] containing the class targets
+ with the 0th index assumed to map to the first non-background class.
+ groundtruth_masks_list: a list of 3-D tf.float32 tensors of
+ shape [num_boxes, height_in, width_in] containing instance
+ masks with values in {0, 1}. If None, no masks are provided.
+ Mask resolution `height_in`x`width_in` must agree with the resolution
+ of the input image tensor provided to the `preprocess` function.
+ groundtruth_keypoints_list: a list of 3-D tf.float32 tensors of
+ shape [num_boxes, num_keypoints, 2] containing keypoints.
+ Keypoints are assumed to be provided in normalized coordinates and
+ missing keypoints should be encoded as NaN.
+ groundtruth_weights_list: A list of 1-D tf.float32 tensors of shape
+ [num_boxes] containing weights for groundtruth boxes.
+ groundtruth_confidences_list: A list of 2-D tf.float32 tensors of shape
+ [num_boxes, num_classes] containing class confidences for groundtruth
+ boxes.
+ groundtruth_is_crowd_list: A list of 1-D tf.bool tensors of shape
+ [num_boxes] containing is_crowd annotations
+ is_annotated_list: A list of scalar tf.bool tensors indicating whether
+ images have been labeled or not.
+ """
+ self._groundtruth_lists[fields.BoxListFields.boxes] = groundtruth_boxes_list
+ self._groundtruth_lists[
+ fields.BoxListFields.classes] = groundtruth_classes_list
+ if groundtruth_weights_list:
+ self._groundtruth_lists[fields.BoxListFields.
+ weights] = groundtruth_weights_list
+ if groundtruth_confidences_list:
+ self._groundtruth_lists[fields.BoxListFields.
+ confidences] = groundtruth_confidences_list
+ if groundtruth_masks_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.masks] = groundtruth_masks_list
+ if groundtruth_keypoints_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.keypoints] = groundtruth_keypoints_list
+ if groundtruth_is_crowd_list:
+ self._groundtruth_lists[
+ fields.BoxListFields.is_crowd] = groundtruth_is_crowd_list
+ if is_annotated_list:
+ self._groundtruth_lists[
+ fields.InputDataFields.is_annotated] = is_annotated_list
+
+ @abc.abstractmethod
+ def regularization_losses(self):
+ """Returns a list of regularization losses for this model.
+
+ Returns a list of regularization losses for this model that the estimator
+ needs to use during training/optimization.
+
+ Returns:
+ A list of regularization loss tensors.
+ """
+ pass
+
+ @abc.abstractmethod
+ def restore_map(self, fine_tune_checkpoint_type='detection'):
+ """Returns a map of variables to load from a foreign checkpoint.
+
+ Returns a map of variable names to load from a checkpoint to variables in
+ the model graph. This enables the model to initialize based on weights from
+ another task. For example, the feature extractor variables from a
+ classification model can be used to bootstrap training of an object
+ detector. When loading from an object detection model, the checkpoint model
+ should have the same parameters as this detection model with exception of
+ the num_classes parameter.
+
+ Args:
+ fine_tune_checkpoint_type: whether to restore from a full detection
+ checkpoint (with compatible variable names) or to restore from a
+ classification checkpoint for initialization prior to training.
+ Valid values: `detection`, `classification`. Default 'detection'.
+
+ Returns:
+ A dict mapping variable names (to load from a checkpoint) to variables in
+ the model graph.
+ """
+ pass
+
+ @abc.abstractmethod
+ def updates(self):
+ """Returns a list of update operators for this model.
+
+ Returns a list of update operators for this model that must be executed at
+ each training step. The estimator's train op needs to have a control
+ dependency on these updates.
+
+ Returns:
+ A list of update operators.
+ """
+ pass
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/multiclass_nms_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/multiclass_nms_test.py
new file mode 100644
index 00000000..7cc01c65
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/multiclass_nms_test.py
@@ -0,0 +1,526 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for tensorflow_models.object_detection.core.post_processing."""
+import numpy as np
+import tensorflow as tf
+from object_detection.core import post_processing
+from object_detection.core import standard_fields as fields
+from object_detection.utils import test_case
+
+
+class MulticlassNonMaxSuppressionTest(test_case.TestCase):
+
+ def test_multiclass_nms_select_with_shared_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_shared_boxes_pad_to_max_output_size(self):
+ boxes = np.array([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], np.float32)
+ scores = np.array([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]], np.float32)
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 4
+ max_output_size = 5
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ def graph_fn(boxes, scores):
+ nms, num_valid_nms_boxes = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=max_output_size,
+ pad_to_max_output_size=True)
+ return [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes), num_valid_nms_boxes]
+
+ [nms_corners_output, nms_scores_output, nms_classes_output,
+ num_valid_nms_boxes] = self.execute(graph_fn, [boxes, scores])
+
+ self.assertEqual(num_valid_nms_boxes, 4)
+ self.assertAllClose(nms_corners_output[0:num_valid_nms_boxes],
+ exp_nms_corners)
+ self.assertAllClose(nms_scores_output[0:num_valid_nms_boxes],
+ exp_nms_scores)
+ self.assertAllClose(nms_classes_output[0:num_valid_nms_boxes],
+ exp_nms_classes)
+
+ def test_multiclass_nms_select_with_shared_boxes_given_keypoints(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ num_keypoints = 6
+ keypoints = tf.tile(
+ tf.reshape(tf.range(8), [8, 1, 1]),
+ [1, num_keypoints, 2])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_keypoints_tensor = tf.tile(
+ tf.reshape(tf.constant([3, 0, 6, 5], dtype=tf.float32), [4, 1, 1]),
+ [1, num_keypoints, 2])
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={fields.BoxListFields.keypoints: keypoints})
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_keypoints,
+ exp_nms_keypoints) = sess.run([
+ nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.keypoints),
+ exp_nms_keypoints_tensor
+ ])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_keypoints, exp_nms_keypoints)
+
+ def test_multiclass_nms_with_shared_boxes_given_keypoint_heatmaps(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+
+ num_boxes = tf.shape(boxes)[0]
+ heatmap_height = 5
+ heatmap_width = 5
+ num_keypoints = 17
+ keypoint_heatmaps = tf.ones(
+ [num_boxes, heatmap_height, heatmap_width, num_keypoints],
+ dtype=tf.float32)
+
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_keypoint_heatmaps = np.ones(
+ (4, heatmap_height, heatmap_width, num_keypoints), dtype=np.float32)
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={
+ fields.BoxListFields.keypoint_heatmaps: keypoint_heatmaps
+ })
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_keypoint_heatmaps) = sess.run(
+ [nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.keypoint_heatmaps)])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_keypoint_heatmaps, exp_nms_keypoint_heatmaps)
+
+ def test_multiclass_nms_with_additional_fields(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+
+ coarse_boxes_key = 'coarse_boxes'
+ coarse_boxes = tf.constant([[0.1, 0.1, 1.1, 1.1],
+ [0.1, 0.2, 1.1, 1.2],
+ [0.1, -0.2, 1.1, 1.0],
+ [0.1, 10.1, 1.1, 11.1],
+ [0.1, 10.2, 1.1, 11.2],
+ [0.1, 100.1, 1.1, 101.1],
+ [0.1, 1000.1, 1.1, 1002.1],
+ [0.1, 1000.1, 1.1, 1002.2]], tf.float32)
+
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = np.array([[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]], dtype=np.float32)
+
+ exp_nms_coarse_corners = np.array([[0.1, 10.1, 1.1, 11.1],
+ [0.1, 0.1, 1.1, 1.1],
+ [0.1, 1000.1, 1.1, 1002.1],
+ [0.1, 100.1, 1.1, 101.1]],
+ dtype=np.float32)
+
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ additional_fields={coarse_boxes_key: coarse_boxes})
+
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_coarse_corners) = sess.run(
+ [nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(coarse_boxes_key)])
+
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_coarse_corners, exp_nms_coarse_corners)
+
+ def test_multiclass_nms_select_with_shared_boxes_given_masks(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ num_classes = 2
+ mask_height = 3
+ mask_width = 3
+ masks = tf.tile(
+ tf.reshape(tf.range(8), [8, 1, 1, 1]),
+ [1, num_classes, mask_height, mask_width])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+ exp_nms_masks_tensor = tf.tile(
+ tf.reshape(tf.constant([3, 0, 6, 5], dtype=tf.float32), [4, 1, 1]),
+ [1, mask_height, mask_width])
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size, masks=masks)
+ with self.test_session() as sess:
+ (nms_corners_output,
+ nms_scores_output,
+ nms_classes_output,
+ nms_masks,
+ exp_nms_masks) = sess.run([nms.get(),
+ nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes),
+ nms.get_field(fields.BoxListFields.masks),
+ exp_nms_masks_tensor])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+ self.assertAllEqual(nms_masks, exp_nms_masks)
+
+ def test_multiclass_nms_select_with_clip_window(self):
+ boxes = tf.constant([[[0, 0, 10, 10]],
+ [[1, 1, 11, 11]]], tf.float32)
+ scores = tf.constant([[.9], [.75]])
+ clip_window = tf.constant([5, 4, 8, 7], tf.float32)
+ score_thresh = 0.0
+ iou_thresh = 0.5
+ max_output_size = 100
+
+ exp_nms_corners = [[5, 4, 8, 7]]
+ exp_nms_scores = [.9]
+ exp_nms_classes = [0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ clip_window=clip_window)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_clip_window_change_coordinate_frame(self):
+ boxes = tf.constant([[[0, 0, 10, 10]],
+ [[1, 1, 11, 11]]], tf.float32)
+ scores = tf.constant([[.9], [.75]])
+ clip_window = tf.constant([5, 4, 8, 7], tf.float32)
+ score_thresh = 0.0
+ iou_thresh = 0.5
+ max_output_size = 100
+
+ exp_nms_corners = [[0, 0, 1, 1]]
+ exp_nms_scores = [.9]
+ exp_nms_classes = [0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_output_size,
+ clip_window=clip_window,
+ change_coordinate_frame=True)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_per_class_cap(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 2
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 1000, 1, 1002]]
+ exp_nms_scores = [.95, .9, .85]
+ exp_nms_classes = [0, 0, 1]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_size_per_class)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_select_with_total_cap(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_size_per_class = 4
+ max_total_size = 2
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1]]
+ exp_nms_scores = [.95, .9]
+ exp_nms_classes = [0, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_size_per_class,
+ max_total_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+ def test_multiclass_nms_threshold_then_select_with_shared_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1]],
+ [[0, 0.1, 1, 1.1]],
+ [[0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101]],
+ [[0, 1000, 1, 1002]],
+ [[0, 1000, 1, 1002.1]]], tf.float32)
+ scores = tf.constant([[.9], [.75], [.6], [.95], [.5], [.3], [.01], [.01]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 3
+
+ exp_nms = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 100, 1, 101]]
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_output = sess.run(nms.get())
+ self.assertAllClose(nms_output, exp_nms)
+
+ def test_multiclass_nms_select_with_separate_boxes(self):
+ boxes = tf.constant([[[0, 0, 1, 1], [0, 0, 4, 5]],
+ [[0, 0.1, 1, 1.1], [0, 0.1, 2, 1.1]],
+ [[0, -0.1, 1, 0.9], [0, -0.1, 1, 0.9]],
+ [[0, 10, 1, 11], [0, 10, 1, 11]],
+ [[0, 10.1, 1, 11.1], [0, 10.1, 1, 11.1]],
+ [[0, 100, 1, 101], [0, 100, 1, 101]],
+ [[0, 1000, 1, 1002], [0, 999, 2, 1004]],
+ [[0, 1000, 1, 1002.1], [0, 999, 2, 1002.7]]],
+ tf.float32)
+ scores = tf.constant([[.9, 0.01], [.75, 0.05],
+ [.6, 0.01], [.95, 0],
+ [.5, 0.01], [.3, 0.01],
+ [.01, .85], [.01, .5]])
+ score_thresh = 0.1
+ iou_thresh = .5
+ max_output_size = 4
+
+ exp_nms_corners = [[0, 10, 1, 11],
+ [0, 0, 1, 1],
+ [0, 999, 2, 1004],
+ [0, 100, 1, 101]]
+ exp_nms_scores = [.95, .9, .85, .3]
+ exp_nms_classes = [0, 0, 1, 0]
+
+ nms, _ = post_processing.multiclass_non_max_suppression(
+ boxes, scores, score_thresh, iou_thresh, max_output_size)
+ with self.test_session() as sess:
+ nms_corners_output, nms_scores_output, nms_classes_output = sess.run(
+ [nms.get(), nms.get_field(fields.BoxListFields.scores),
+ nms.get_field(fields.BoxListFields.classes)])
+ self.assertAllClose(nms_corners_output, exp_nms_corners)
+ self.assertAllClose(nms_scores_output, exp_nms_scores)
+ self.assertAllClose(nms_classes_output, exp_nms_classes)
+
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/post_processing.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/post_processing.py
new file mode 100644
index 00000000..90f1e06d
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/post_processing.py
@@ -0,0 +1,1223 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Post-processing operations on detected boxes."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import numpy as np
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import standard_fields as fields
+from object_detection.utils import shape_utils
+
+_NMS_TILE_SIZE = 512
+
+
+def batch_iou(boxes1, boxes2):
+ """Calculates the overlap between proposal and ground truth boxes.
+
+ Some `boxes2` may have been padded. The returned `iou` tensor for these
+ boxes will be -1.
+
+ Args:
+ boxes1: a tensor with a shape of [batch_size, N, 4]. N is the number of
+ proposals before groundtruth assignment. The last dimension is the pixel
+ coordinates in [ymin, xmin, ymax, xmax] form.
+ boxes2: a tensor with a shape of [batch_size, MAX_NUM_INSTANCES, 4]. This
+ tensor might have paddings with a negative value.
+
+ Returns:
+ iou: a tensor with as a shape of [batch_size, N, MAX_NUM_INSTANCES].
+ """
+ with tf.name_scope('BatchIOU'):
+ y1_min, x1_min, y1_max, x1_max = tf.split(
+ value=boxes1, num_or_size_splits=4, axis=2)
+ y2_min, x2_min, y2_max, x2_max = tf.split(
+ value=boxes2, num_or_size_splits=4, axis=2)
+
+ # Calculates the intersection area.
+ intersection_xmin = tf.maximum(x1_min, tf.transpose(x2_min, [0, 2, 1]))
+ intersection_xmax = tf.minimum(x1_max, tf.transpose(x2_max, [0, 2, 1]))
+ intersection_ymin = tf.maximum(y1_min, tf.transpose(y2_min, [0, 2, 1]))
+ intersection_ymax = tf.minimum(y1_max, tf.transpose(y2_max, [0, 2, 1]))
+ intersection_area = tf.maximum(
+ (intersection_xmax - intersection_xmin), 0) * tf.maximum(
+ (intersection_ymax - intersection_ymin), 0)
+
+ # Calculates the union area.
+ area1 = (y1_max - y1_min) * (x1_max - x1_min)
+ area2 = (y2_max - y2_min) * (x2_max - x2_min)
+ # Adds a small epsilon to avoid divide-by-zero.
+ union_area = area1 + tf.transpose(area2,
+ [0, 2, 1]) - intersection_area + 1e-8
+
+ # Calculates IoU.
+ iou = intersection_area / union_area
+
+ # Fills -1 for padded ground truth boxes.
+ padding_mask = tf.logical_and(
+ tf.less(intersection_xmax, 0), tf.less(intersection_ymax, 0))
+ iou = tf.where(padding_mask, -tf.ones_like(iou), iou)
+
+ return iou
+
+
+def _self_suppression(iou, iou_threshold, loop_condition, iou_sum):
+ """Bounding-boxes self-suppression loop body.
+
+ Args:
+ iou: A float Tensor with shape [1, num_boxes, max_num_instance]: IOUs.
+ iou_threshold: A scalar, representing IOU threshold.
+ loop_condition: The loop condition returned from last iteration.
+ iou_sum: iou_sum_new returned from last iteration.
+
+ Returns:
+ iou_suppressed: A float Tensor with shape [1, num_boxes, max_num_instance],
+ IOU after suppression.
+ iou_threshold: A scalar, representing IOU threshold.
+ loop_condition: Bool Tensor of shape [], the loop condition.
+ iou_sum_new: The new IOU sum.
+ """
+ del loop_condition
+ can_suppress_others = tf.cast(
+ tf.reshape(tf.reduce_max(iou, 1) <= iou_threshold, [1, -1, 1]), iou.dtype)
+ iou_suppressed = tf.reshape(
+ tf.cast(
+ tf.reduce_max(can_suppress_others * iou, 1) <= iou_threshold,
+ iou.dtype), [1, -1, 1]) * iou
+ iou_sum_new = tf.reduce_sum(iou_suppressed, [1, 2])
+ return [
+ iou_suppressed, iou_threshold,
+ tf.reduce_any(iou_sum - iou_sum_new > iou_threshold), iou_sum_new
+ ]
+
+
+def _cross_suppression(boxes, box_slice, iou_threshold, inner_idx):
+ """Bounding-boxes cross-suppression loop body.
+
+ Args:
+ boxes: A float Tensor of shape [1, anchors, 4], representing boxes.
+ box_slice: A float Tensor of shape [1, _NMS_TILE_SIZE, 4], the box tile
+ returned from last iteration
+ iou_threshold: A scalar, representing IOU threshold.
+ inner_idx: A scalar, representing inner index.
+
+ Returns:
+ boxes: A float Tensor of shape [1, anchors, 4], representing boxes.
+ ret_slice: A float Tensor of shape [1, _NMS_TILE_SIZE, 4], the box tile
+ after suppression
+ iou_threshold: A scalar, representing IOU threshold.
+ inner_idx: A scalar, inner index incremented.
+ """
+ new_slice = tf.slice(boxes, [0, inner_idx * _NMS_TILE_SIZE, 0],
+ [1, _NMS_TILE_SIZE, 4])
+ iou = batch_iou(new_slice, box_slice)
+ ret_slice = tf.expand_dims(
+ tf.cast(tf.reduce_all(iou < iou_threshold, [1]), box_slice.dtype),
+ 2) * box_slice
+ return boxes, ret_slice, iou_threshold, inner_idx + 1
+
+
+def _suppression_loop_body(boxes, iou_threshold, output_size, idx):
+ """Process boxes in the range [idx*_NMS_TILE_SIZE, (idx+1)*_NMS_TILE_SIZE).
+
+ Args:
+ boxes: a tensor with a shape of [1, anchors, 4].
+ iou_threshold: a float representing the threshold for deciding whether boxes
+ overlap too much with respect to IOU.
+ output_size: an int32 tensor of size [1]. Representing the number of
+ selected boxes.
+ idx: an integer scalar representing induction variable.
+
+ Returns:
+ boxes: updated boxes.
+ iou_threshold: pass down iou_threshold to the next iteration.
+ output_size: the updated output_size.
+ idx: the updated induction variable.
+ """
+ num_tiles = tf.shape(boxes)[1] // _NMS_TILE_SIZE
+
+ # Iterates over tiles that can possibly suppress the current tile.
+ box_slice = tf.slice(boxes, [0, idx * _NMS_TILE_SIZE, 0],
+ [1, _NMS_TILE_SIZE, 4])
+ _, box_slice, _, _ = tf.while_loop(
+ lambda _boxes, _box_slice, _threshold, inner_idx: inner_idx < idx,
+ _cross_suppression, [boxes, box_slice, iou_threshold,
+ tf.constant(0)])
+
+ # Iterates over the current tile to compute self-suppression.
+ iou = batch_iou(box_slice, box_slice)
+ mask = tf.expand_dims(
+ tf.reshape(tf.range(_NMS_TILE_SIZE), [1, -1]) > tf.reshape(
+ tf.range(_NMS_TILE_SIZE), [-1, 1]), 0)
+ iou *= tf.cast(tf.logical_and(mask, iou >= iou_threshold), iou.dtype)
+ suppressed_iou, _, _, _ = tf.while_loop(
+ lambda _iou, _threshold, loop_condition, _iou_sum: loop_condition,
+ _self_suppression,
+ [iou, iou_threshold,
+ tf.constant(True),
+ tf.reduce_sum(iou, [1, 2])])
+ suppressed_box = tf.reduce_sum(suppressed_iou, 1) > 0
+ box_slice *= tf.expand_dims(1.0 - tf.cast(suppressed_box, box_slice.dtype), 2)
+
+ # Uses box_slice to update the input boxes.
+ mask = tf.reshape(
+ tf.cast(tf.equal(tf.range(num_tiles), idx), boxes.dtype), [1, -1, 1, 1])
+ boxes = tf.tile(tf.expand_dims(box_slice, [1]),
+ [1, num_tiles, 1, 1]) * mask + tf.reshape(
+ boxes, [1, num_tiles, _NMS_TILE_SIZE, 4]) * (1 - mask)
+ boxes = tf.reshape(boxes, [1, -1, 4])
+
+ # Updates output_size.
+ output_size += tf.reduce_sum(
+ tf.cast(tf.reduce_any(box_slice > 0, [2]), tf.int32), [1])
+ return boxes, iou_threshold, output_size, idx + 1
+
+
+def partitioned_non_max_suppression_padded(boxes,
+ scores,
+ max_output_size,
+ iou_threshold=0.5,
+ score_threshold=float('-inf')):
+ """A tiled version of [`tf.image.non_max_suppression_padded`](https://www.tensorflow.org/api_docs/python/tf/image/non_max_suppression_padded).
+
+ The overall design of the algorithm is to handle boxes tile-by-tile:
+
+ boxes = boxes.pad_to_multiple_of(tile_size)
+ num_tiles = len(boxes) // tile_size
+ output_boxes = []
+ for i in range(num_tiles):
+ box_tile = boxes[i*tile_size : (i+1)*tile_size]
+ for j in range(i - 1):
+ suppressing_tile = boxes[j*tile_size : (j+1)*tile_size]
+ iou = batch_iou(box_tile, suppressing_tile)
+ # if the box is suppressed in iou, clear it to a dot
+ box_tile *= _update_boxes(iou)
+ # Iteratively handle the diagonal tile.
+ iou = _box_overlap(box_tile, box_tile)
+ iou_changed = True
+ while iou_changed:
+ # boxes that are not suppressed by anything else
+ suppressing_boxes = _get_suppressing_boxes(iou)
+ # boxes that are suppressed by suppressing_boxes
+ suppressed_boxes = _get_suppressed_boxes(iou, suppressing_boxes)
+ # clear iou to 0 for boxes that are suppressed, as they cannot be used
+ # to suppress other boxes any more
+ new_iou = _clear_iou(iou, suppressed_boxes)
+ iou_changed = (new_iou != iou)
+ iou = new_iou
+ # remaining boxes that can still suppress others, are selected boxes.
+ output_boxes.append(_get_suppressing_boxes(iou))
+ if len(output_boxes) >= max_output_size:
+ break
+
+ Args:
+ boxes: A 2-D float `Tensor` of shape `[num_boxes, 4]`.
+ scores: A 1-D float `Tensor` of shape `[num_boxes]` representing a single
+ score corresponding to each box (each row of boxes).
+ max_output_size: a scalar integer `Tensor` representing the maximum number
+ of boxes to be selected by non max suppression.
+ iou_threshold: a float representing the threshold for deciding whether boxes
+ overlap too much with respect to IOU.
+ score_threshold: A float representing the threshold for deciding when to
+ remove boxes based on score.
+
+ Returns:
+ selected_indices: a tensor of shape [anchors].
+ num_valid_boxes: a scalar int tensor.
+ nms_proposals: a tensor with a shape of [anchors, 4]. It has
+ same dtype as input boxes.
+ nms_scores: a tensor with a shape of [anchors]. It has same
+ dtype as input scores.
+ argsort_ids: a tensor of shape [anchors], mapping from input order of boxes
+ to output order of boxes.
+ """
+ num_boxes = tf.shape(boxes)[0]
+ pad = tf.cast(
+ tf.ceil(tf.cast(num_boxes, tf.float32) / _NMS_TILE_SIZE),
+ tf.int32) * _NMS_TILE_SIZE - num_boxes
+
+ scores, argsort_ids = tf.nn.top_k(scores, k=num_boxes, sorted=True)
+ boxes = tf.gather(boxes, argsort_ids)
+ num_boxes = tf.shape(boxes)[0]
+ num_boxes += pad
+ boxes = tf.pad(
+ tf.cast(boxes, tf.float32), [[0, pad], [0, 0]], constant_values=-1)
+ scores = tf.pad(tf.cast(scores, tf.float32), [[0, pad]])
+
+ # mask boxes to -1 by score threshold
+ scores_mask = tf.expand_dims(
+ tf.cast(scores > score_threshold, boxes.dtype), axis=1)
+ boxes = ((boxes + 1.) * scores_mask) - 1.
+
+ boxes = tf.expand_dims(boxes, axis=0)
+ scores = tf.expand_dims(scores, axis=0)
+
+ def _loop_cond(unused_boxes, unused_threshold, output_size, idx):
+ return tf.logical_and(
+ tf.reduce_min(output_size) < max_output_size,
+ idx < num_boxes // _NMS_TILE_SIZE)
+
+ selected_boxes, _, output_size, _ = tf.while_loop(
+ _loop_cond, _suppression_loop_body,
+ [boxes, iou_threshold,
+ tf.zeros([1], tf.int32),
+ tf.constant(0)])
+ idx = num_boxes - tf.cast(
+ tf.nn.top_k(
+ tf.cast(tf.reduce_any(selected_boxes > 0, [2]), tf.int32) *
+ tf.expand_dims(tf.range(num_boxes, 0, -1), 0), max_output_size)[0],
+ tf.int32)
+ idx = tf.minimum(idx, num_boxes - 1 - pad)
+ idx = tf.reshape(idx + tf.reshape(tf.range(1) * num_boxes, [-1, 1]), [-1])
+ num_valid_boxes = tf.reduce_sum(output_size)
+ return (idx, num_valid_boxes, tf.reshape(boxes, [-1, 4]),
+ tf.reshape(scores, [-1]), argsort_ids)
+
+
+def _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window):
+ """Validates boxes, scores and iou_thresh.
+
+ This function validates the boxes, scores, iou_thresh
+ and if change_coordinate_frame is True, clip_window must be specified.
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not
+ have a valid scores field.
+ """
+ if not 0 <= iou_thresh <= 1.0:
+ raise ValueError('iou_thresh must be between 0 and 1')
+ if scores.shape.ndims != 2:
+ raise ValueError('scores field must be of rank 2')
+ if shape_utils.get_dim_as_int(scores.shape[1]) is None:
+ raise ValueError('scores must have statically defined second ' 'dimension')
+ if boxes.shape.ndims != 3:
+ raise ValueError('boxes must be of rank 3.')
+ if not (shape_utils.get_dim_as_int(
+ boxes.shape[1]) == shape_utils.get_dim_as_int(scores.shape[1]) or
+ shape_utils.get_dim_as_int(boxes.shape[1]) == 1):
+ raise ValueError('second dimension of boxes must be either 1 or equal '
+ 'to the second dimension of scores')
+ if shape_utils.get_dim_as_int(boxes.shape[2]) != 4:
+ raise ValueError('last dimension of boxes must be of size 4.')
+ if change_coordinate_frame and clip_window is None:
+ raise ValueError('if change_coordinate_frame is True, then a clip_window'
+ 'must be specified.')
+
+
+def _clip_window_prune_boxes(sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame):
+ """Prune boxes with zero area.
+
+ Args:
+ sorted_boxes: A BoxList containing k detections.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ pad_to_max_output_size: flag indicating whether to pad to max output size or
+ not.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided).
+
+ Returns:
+ sorted_boxes: A BoxList containing k detections after pruning.
+ num_valid_nms_boxes_cumulative: Number of valid NMS boxes
+ """
+ sorted_boxes = box_list_ops.clip_to_window(
+ sorted_boxes,
+ clip_window,
+ filter_nonoverlapping=not pad_to_max_output_size)
+ # Set the scores of boxes with zero area to -1 to keep the default
+ # behaviour of pruning out zero area boxes.
+ sorted_boxes_size = tf.shape(sorted_boxes.get())[0]
+ non_zero_box_area = tf.cast(box_list_ops.area(sorted_boxes), tf.bool)
+ sorted_boxes_scores = tf.where(
+ non_zero_box_area, sorted_boxes.get_field(fields.BoxListFields.scores),
+ -1 * tf.ones(sorted_boxes_size))
+ sorted_boxes.add_field(fields.BoxListFields.scores, sorted_boxes_scores)
+ num_valid_nms_boxes_cumulative = tf.reduce_sum(
+ tf.cast(tf.greater_equal(sorted_boxes_scores, 0), tf.int32))
+ sorted_boxes = box_list_ops.sort_by_field(sorted_boxes,
+ fields.BoxListFields.scores)
+ if change_coordinate_frame:
+ sorted_boxes = box_list_ops.change_coordinate_frame(sorted_boxes,
+ clip_window)
+ return sorted_boxes, num_valid_nms_boxes_cumulative
+
+
+def multiclass_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ masks=None,
+ boundaries=None,
+ pad_to_max_output_size=False,
+ use_partitioned_nms=False,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None):
+ """Multi-class version of non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. It operates independently for each class for
+ which scores are provided (via the scores field of the input box_list),
+ pruning boxes with score less than a provided threshold prior to
+ applying NMS.
+
+ Please note that this operation is performed on *all* classes, therefore any
+ background classes should be removed prior to calling this function.
+
+ Selected boxes are guaranteed to be sorted in decreasing order by score (but
+ the sort is not guaranteed to be stable).
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_size_per_class: maximum number of retained boxes per class.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window
+ is provided)
+ masks: (optional) a [k, q, mask_height, mask_width] float32 tensor
+ containing box masks. `q` can be either number of classes or 1 depending
+ on whether a separate mask is predicted per class.
+ boundaries: (optional) a [k, q, boundary_height, boundary_width] float32
+ tensor containing box boundaries. `q` can be either number of classes or 1
+ depending on whether a separate boundary is predicted per class.
+ pad_to_max_output_size: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class`. Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose first dimensions are all of size `k`. After non-maximum
+ suppression, all tensors corresponding to the selected boxes will be
+ added to resulting BoxList.
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: name scope.
+
+ Returns:
+ A tuple of sorted_boxes and num_valid_nms_boxes. The sorted_boxes is a
+ BoxList holds M boxes with a rank-1 scores field representing
+ corresponding scores for each box with scores sorted in decreasing order
+ and a rank-1 classes field representing a class label for each box. The
+ num_valid_nms_boxes is a 0-D integer tensor representing the number of
+ valid elements in `BoxList`, with the valid elements appearing first.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not have
+ a valid scores field.
+ ValueError: if Soft NMS (tf.image.non_max_suppression_with_scores) is not
+ supported in the current TF version and `soft_nms_sigma` is nonzero.
+ """
+ _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window)
+ if pad_to_max_output_size and soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS (soft_nms_sigma != 0.0) is currently not '
+ 'supported when pad_to_max_output_size is True.')
+
+ with tf.name_scope(scope, 'MultiClassNonMaxSuppression'):
+ num_scores = tf.shape(scores)[0]
+ num_classes = shape_utils.get_dim_as_int(scores.get_shape()[1])
+
+ selected_boxes_list = []
+ num_valid_nms_boxes_cumulative = tf.constant(0)
+ per_class_boxes_list = tf.unstack(boxes, axis=1)
+ if masks is not None:
+ per_class_masks_list = tf.unstack(masks, axis=1)
+ if boundaries is not None:
+ per_class_boundaries_list = tf.unstack(boundaries, axis=1)
+ boxes_ids = (range(num_classes) if len(per_class_boxes_list) > 1
+ else [0] * num_classes)
+ for class_idx, boxes_idx in zip(range(num_classes), boxes_ids):
+ per_class_boxes = per_class_boxes_list[boxes_idx]
+ boxlist_and_class_scores = box_list.BoxList(per_class_boxes)
+ class_scores = tf.reshape(
+ tf.slice(scores, [0, class_idx], tf.stack([num_scores, 1])), [-1])
+
+ boxlist_and_class_scores.add_field(fields.BoxListFields.scores,
+ class_scores)
+ if masks is not None:
+ per_class_masks = per_class_masks_list[boxes_idx]
+ boxlist_and_class_scores.add_field(fields.BoxListFields.masks,
+ per_class_masks)
+ if boundaries is not None:
+ per_class_boundaries = per_class_boundaries_list[boxes_idx]
+ boxlist_and_class_scores.add_field(fields.BoxListFields.boundaries,
+ per_class_boundaries)
+ if additional_fields is not None:
+ for key, tensor in additional_fields.items():
+ boxlist_and_class_scores.add_field(key, tensor)
+
+ nms_result = None
+ selected_scores = None
+ if pad_to_max_output_size:
+ max_selection_size = max_size_per_class
+ if use_partitioned_nms:
+ (selected_indices, num_valid_nms_boxes,
+ boxlist_and_class_scores.data['boxes'],
+ boxlist_and_class_scores.data['scores'],
+ _) = partitioned_non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ else:
+ selected_indices, num_valid_nms_boxes = (
+ tf.image.non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(
+ fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_to_max_output_size=True))
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ else:
+ max_selection_size = tf.minimum(max_size_per_class,
+ boxlist_and_class_scores.num_boxes())
+ if (hasattr(tf.image, 'non_max_suppression_with_scores') and
+ tf.compat.forward_compatible(2019, 6, 6)):
+ (selected_indices, selected_scores
+ ) = tf.image.non_max_suppression_with_scores(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ soft_nms_sigma=soft_nms_sigma)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ selected_scores = tf.concat(
+ [selected_scores,
+ tf.zeros(max_selection_size-num_valid_nms_boxes,
+ tf.float32)], -1)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ else:
+ if soft_nms_sigma != 0:
+ raise ValueError('Soft NMS not supported in current TF version!')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ # Make the scores -1 for invalid boxes.
+ valid_nms_boxes_indices = tf.less(
+ tf.range(max_selection_size), num_valid_nms_boxes)
+
+ nms_result.add_field(
+ fields.BoxListFields.scores,
+ tf.where(valid_nms_boxes_indices,
+ selected_scores, -1*tf.ones(max_selection_size)))
+ num_valid_nms_boxes_cumulative += num_valid_nms_boxes
+
+ nms_result.add_field(
+ fields.BoxListFields.classes, (tf.zeros_like(
+ nms_result.get_field(fields.BoxListFields.scores)) + class_idx))
+ selected_boxes_list.append(nms_result)
+ selected_boxes = box_list_ops.concatenate(selected_boxes_list)
+ sorted_boxes = box_list_ops.sort_by_field(selected_boxes,
+ fields.BoxListFields.scores)
+ if clip_window is not None:
+ # When pad_to_max_output_size is False, it prunes the boxes with zero
+ # area.
+ sorted_boxes, num_valid_nms_boxes_cumulative = _clip_window_prune_boxes(
+ sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame)
+
+ if max_total_size:
+ max_total_size = tf.minimum(max_total_size, sorted_boxes.num_boxes())
+ sorted_boxes = box_list_ops.gather(sorted_boxes, tf.range(max_total_size))
+ num_valid_nms_boxes_cumulative = tf.where(
+ max_total_size > num_valid_nms_boxes_cumulative,
+ num_valid_nms_boxes_cumulative, max_total_size)
+ # Select only the valid boxes if pad_to_max_output_size is False.
+ if not pad_to_max_output_size:
+ sorted_boxes = box_list_ops.gather(
+ sorted_boxes, tf.range(num_valid_nms_boxes_cumulative))
+
+ return sorted_boxes, num_valid_nms_boxes_cumulative
+
+
+def class_agnostic_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_classes_per_detection=1,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ masks=None,
+ boundaries=None,
+ pad_to_max_output_size=False,
+ use_partitioned_nms=False,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None):
+ """Class-agnostic version of non maximum suppression.
+
+ This op greedily selects a subset of detection bounding boxes, pruning
+ away boxes that have high IOU (intersection over union) overlap (> thresh)
+ with already selected boxes. It operates on all the boxes using
+ max scores across all classes for which scores are provided (via the scores
+ field of the input box_list), pruning boxes with score less than a provided
+ threshold prior to applying NMS.
+
+ Please note that this operation is performed in a class-agnostic way,
+ therefore any background classes should be removed prior to calling this
+ function.
+
+ Selected boxes are guaranteed to be sorted in decreasing order by score (but
+ the sort is not guaranteed to be stable).
+
+ Args:
+ boxes: A [k, q, 4] float32 tensor containing k detections. `q` can be either
+ number of classes or 1 depending on whether a separate box is predicted
+ per class.
+ scores: A [k, num_classes] float32 tensor containing the scores for each of
+ the k detections. The scores have to be non-negative when
+ pad_to_max_output_size is True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_classes_per_detection: maximum number of retained classes per detection
+ box in class-agnostic NMS.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of the form [y_min, x_min, y_max, x_max]
+ representing the window to clip and normalize boxes to before performing
+ non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ masks: (optional) a [k, q, mask_height, mask_width] float32 tensor
+ containing box masks. `q` can be either number of classes or 1 depending
+ on whether a separate mask is predicted per class.
+ boundaries: (optional) a [k, q, boundary_height, boundary_width] float32
+ tensor containing box boundaries. `q` can be either number of classes or 1
+ depending on whether a separate boundary is predicted per class.
+ pad_to_max_output_size: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class`. Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose first dimensions are all of size `k`. After non-maximum
+ suppression, all tensors corresponding to the selected boxes will be added
+ to resulting BoxList.
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: name scope.
+
+ Returns:
+ A tuple of sorted_boxes and num_valid_nms_boxes. The sorted_boxes is a
+ BoxList holds M boxes with a rank-1 scores field representing
+ corresponding scores for each box with scores sorted in decreasing order
+ and a rank-1 classes field representing a class label for each box. The
+ num_valid_nms_boxes is a 0-D integer tensor representing the number of
+ valid elements in `BoxList`, with the valid elements appearing first.
+
+ Raises:
+ ValueError: if iou_thresh is not in [0, 1] or if input boxlist does not have
+ a valid scores field or if non-zero soft_nms_sigma is provided when
+ pad_to_max_output_size is True.
+ """
+ _validate_boxes_scores_iou_thresh(boxes, scores, iou_thresh,
+ change_coordinate_frame, clip_window)
+ if pad_to_max_output_size and soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS (soft_nms_sigma != 0.0) is currently not '
+ 'supported when pad_to_max_output_size is True.')
+
+ if max_classes_per_detection > 1:
+ raise ValueError('Max classes per detection box >1 not supported.')
+ q = shape_utils.get_dim_as_int(boxes.shape[1])
+ if q > 1:
+ class_ids = tf.expand_dims(
+ tf.argmax(scores, axis=1, output_type=tf.int32), axis=1)
+ boxes = tf.batch_gather(boxes, class_ids)
+ if masks is not None:
+ masks = tf.batch_gather(masks, class_ids)
+ if boundaries is not None:
+ boundaries = tf.batch_gather(boundaries, class_ids)
+ boxes = tf.squeeze(boxes, axis=[1])
+ if masks is not None:
+ masks = tf.squeeze(masks, axis=[1])
+ if boundaries is not None:
+ boundaries = tf.squeeze(boundaries, axis=[1])
+
+ with tf.name_scope(scope, 'ClassAgnosticNonMaxSuppression'):
+ boxlist_and_class_scores = box_list.BoxList(boxes)
+ max_scores = tf.reduce_max(scores, axis=-1)
+ classes_with_max_scores = tf.argmax(scores, axis=-1)
+ boxlist_and_class_scores.add_field(fields.BoxListFields.scores, max_scores)
+ if masks is not None:
+ boxlist_and_class_scores.add_field(fields.BoxListFields.masks, masks)
+ if boundaries is not None:
+ boxlist_and_class_scores.add_field(fields.BoxListFields.boundaries,
+ boundaries)
+
+ if additional_fields is not None:
+ for key, tensor in additional_fields.items():
+ boxlist_and_class_scores.add_field(key, tensor)
+
+ nms_result = None
+ selected_scores = None
+ if pad_to_max_output_size:
+ max_selection_size = max_total_size
+ if use_partitioned_nms:
+ (selected_indices, num_valid_nms_boxes,
+ boxlist_and_class_scores.data['boxes'],
+ boxlist_and_class_scores.data['scores'],
+ argsort_ids) = partitioned_non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ classes_with_max_scores = tf.gather(classes_with_max_scores,
+ argsort_ids)
+ else:
+ selected_indices, num_valid_nms_boxes = (
+ tf.image.non_max_suppression_padded(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_to_max_output_size=True))
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ else:
+ max_selection_size = tf.minimum(max_total_size,
+ boxlist_and_class_scores.num_boxes())
+ if (hasattr(tf.image, 'non_max_suppression_with_scores') and
+ tf.compat.forward_compatible(2019, 6, 6)):
+ (selected_indices, selected_scores
+ ) = tf.image.non_max_suppression_with_scores(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ soft_nms_sigma=soft_nms_sigma)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat([
+ selected_indices,
+ tf.zeros(max_selection_size - num_valid_nms_boxes, tf.int32)
+ ], 0)
+ selected_scores = tf.concat(
+ [selected_scores,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.float32)], -1)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ else:
+ if soft_nms_sigma != 0:
+ raise ValueError('Soft NMS not supported in current TF version!')
+ selected_indices = tf.image.non_max_suppression(
+ boxlist_and_class_scores.get(),
+ boxlist_and_class_scores.get_field(fields.BoxListFields.scores),
+ max_selection_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh)
+ num_valid_nms_boxes = tf.shape(selected_indices)[0]
+ selected_indices = tf.concat(
+ [selected_indices,
+ tf.zeros(max_selection_size-num_valid_nms_boxes, tf.int32)], 0)
+ nms_result = box_list_ops.gather(boxlist_and_class_scores,
+ selected_indices)
+ selected_scores = nms_result.get_field(fields.BoxListFields.scores)
+ valid_nms_boxes_indices = tf.less(
+ tf.range(max_selection_size), num_valid_nms_boxes)
+ nms_result.add_field(
+ fields.BoxListFields.scores,
+ tf.where(valid_nms_boxes_indices,
+ selected_scores, -1*tf.ones(max_selection_size)))
+
+ selected_classes = tf.gather(classes_with_max_scores, selected_indices)
+ selected_classes = tf.cast(selected_classes, tf.float32)
+ nms_result.add_field(fields.BoxListFields.classes, selected_classes)
+ selected_boxes = nms_result
+ sorted_boxes = box_list_ops.sort_by_field(selected_boxes,
+ fields.BoxListFields.scores)
+
+ if clip_window is not None:
+ # When pad_to_max_output_size is False, it prunes the boxes with zero
+ # area.
+ sorted_boxes, num_valid_nms_boxes = _clip_window_prune_boxes(
+ sorted_boxes, clip_window, pad_to_max_output_size,
+ change_coordinate_frame)
+
+ if max_total_size:
+ max_total_size = tf.minimum(max_total_size, sorted_boxes.num_boxes())
+ sorted_boxes = box_list_ops.gather(sorted_boxes, tf.range(max_total_size))
+ num_valid_nms_boxes = tf.where(max_total_size > num_valid_nms_boxes,
+ num_valid_nms_boxes, max_total_size)
+ # Select only the valid boxes if pad_to_max_output_size is False.
+ if not pad_to_max_output_size:
+ sorted_boxes = box_list_ops.gather(sorted_boxes,
+ tf.range(num_valid_nms_boxes))
+
+ return sorted_boxes, num_valid_nms_boxes
+
+
+def batch_multiclass_non_max_suppression(boxes,
+ scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size=0,
+ clip_window=None,
+ change_coordinate_frame=False,
+ num_valid_boxes=None,
+ masks=None,
+ additional_fields=None,
+ soft_nms_sigma=0.0,
+ scope=None,
+ use_static_shapes=False,
+ use_partitioned_nms=False,
+ parallel_iterations=32,
+ use_class_agnostic_nms=False,
+ max_classes_per_detection=1,
+ use_dynamic_map_fn=False,
+ use_combined_nms=False):
+ """Multi-class version of non maximum suppression that operates on a batch.
+
+ This op is similar to `multiclass_non_max_suppression` but operates on a batch
+ of boxes and scores. See documentation for `multiclass_non_max_suppression`
+ for details.
+
+ Args:
+ boxes: A [batch_size, num_anchors, q, 4] float32 tensor containing
+ detections. If `q` is 1 then same boxes are used for all classes
+ otherwise, if `q` is equal to number of classes, class-specific boxes are
+ used.
+ scores: A [batch_size, num_anchors, num_classes] float32 tensor containing
+ the scores for each of the `num_anchors` detections. The scores have to be
+ non-negative when use_static_shapes is set True.
+ score_thresh: scalar threshold for score (low scoring boxes are removed).
+ iou_thresh: scalar threshold for IOU (new boxes that have high IOU overlap
+ with previously selected boxes are removed).
+ max_size_per_class: maximum number of retained boxes per class.
+ max_total_size: maximum number of boxes retained over all classes. By
+ default returns all boxes retained after capping boxes per class.
+ clip_window: A float32 tensor of shape [batch_size, 4] where each entry is
+ of the form [y_min, x_min, y_max, x_max] representing the window to clip
+ boxes to before performing non-max suppression. This argument can also be
+ a tensor of shape [4] in which case, the same clip window is applied to
+ all images in the batch. If clip_widow is None, all boxes are used to
+ perform non-max suppression.
+ change_coordinate_frame: Whether to normalize coordinates after clipping
+ relative to clip_window (this can only be set to True if a clip_window is
+ provided)
+ num_valid_boxes: (optional) a Tensor of type `int32`. A 1-D tensor of shape
+ [batch_size] representing the number of valid boxes to be considered for
+ each image in the batch. This parameter allows for ignoring zero
+ paddings.
+ masks: (optional) a [batch_size, num_anchors, q, mask_height, mask_width]
+ float32 tensor containing box masks. `q` can be either number of classes
+ or 1 depending on whether a separate mask is predicted per class.
+ additional_fields: (optional) If not None, a dictionary that maps keys to
+ tensors whose dimensions are [batch_size, num_anchors, ...].
+ soft_nms_sigma: A scalar float representing the Soft NMS sigma parameter;
+ See Bodla et al, https://arxiv.org/abs/1704.04503). When
+ `soft_nms_sigma=0.0` (which is default), we fall back to standard (hard)
+ NMS. Soft NMS is currently only supported when pad_to_max_output_size is
+ False.
+ scope: tf scope name.
+ use_static_shapes: If true, the output nmsed boxes are padded to be of
+ length `max_size_per_class` and it doesn't clip boxes to max_total_size.
+ Defaults to false.
+ use_partitioned_nms: If true, use partitioned version of
+ non_max_suppression.
+ parallel_iterations: (optional) number of batch items to process in
+ parallel.
+ use_class_agnostic_nms: If true, this uses class-agnostic non max
+ suppression
+ max_classes_per_detection: Maximum number of retained classes per detection
+ box in class-agnostic NMS.
+ use_dynamic_map_fn: If true, images in the batch will be processed within a
+ dynamic loop. Otherwise, a static loop will be used if possible.
+ use_combined_nms: If true, it uses tf.image.combined_non_max_suppression (
+ multi-class version of NMS that operates on a batch).
+ It greedily selects a subset of detection bounding boxes, pruning away
+ boxes that have high IOU (intersection over union) overlap (> thresh) with
+ already selected boxes. It operates independently for each batch.
+ Within each batch, it operates independently for each class for which
+ scores are provided (via the scores field of the input box_list),
+ pruning boxes with score less than a provided threshold prior to applying
+ NMS. This operation is performed on *all* batches and *all* classes
+ in the batch, therefore any background classes should be removed prior to
+ calling this function.
+ Masks and additional fields are not supported.
+ See argument checks in the code below for unsupported arguments.
+
+ Returns:
+ 'nmsed_boxes': A [batch_size, max_detections, 4] float32 tensor
+ containing the non-max suppressed boxes.
+ 'nmsed_scores': A [batch_size, max_detections] float32 tensor containing
+ the scores for the boxes.
+ 'nmsed_classes': A [batch_size, max_detections] float32 tensor
+ containing the class for boxes.
+ 'nmsed_masks': (optional) a
+ [batch_size, max_detections, mask_height, mask_width] float32 tensor
+ containing masks for each selected box. This is set to None if input
+ `masks` is None.
+ 'nmsed_additional_fields': (optional) a dictionary of
+ [batch_size, max_detections, ...] float32 tensors corresponding to the
+ tensors specified in the input `additional_fields`. This is not returned
+ if input `additional_fields` is None.
+ 'num_detections': A [batch_size] int32 tensor indicating the number of
+ valid detections per batch item. Only the top num_detections[i] entries in
+ nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
+ entries are zero paddings.
+
+ Raises:
+ ValueError: if `q` in boxes.shape is not 1 or not equal to number of
+ classes as inferred from scores.shape.
+ """
+ if use_combined_nms:
+ if change_coordinate_frame:
+ raise ValueError(
+ 'change_coordinate_frame (normalizing coordinates'
+ ' relative to clip_window) is not supported by combined_nms.')
+ if num_valid_boxes is not None:
+ raise ValueError('num_valid_boxes is not supported by combined_nms.')
+ if masks is not None:
+ raise ValueError('masks is not supported by combined_nms.')
+ if soft_nms_sigma != 0.0:
+ raise ValueError('Soft NMS is not supported by combined_nms.')
+ if use_class_agnostic_nms:
+ raise ValueError('class-agnostic NMS is not supported by combined_nms.')
+ if clip_window is not None:
+ tf.compat.v1.logging.warning(
+ 'clip_window is not supported by combined_nms unless it is'
+ ' [0. 0. 1. 1.] for each image.')
+ if additional_fields is not None:
+ tf.compat.v1.logging.warning(
+ 'additional_fields is not supported by combined_nms.')
+ if parallel_iterations != 32:
+ tf.compat.v1.logging.warning(
+ 'Number of batch items to be processed in parallel is'
+ ' not configurable by combined_nms.')
+ if max_classes_per_detection > 1:
+ tf.compat.v1.logging.warning(
+ 'max_classes_per_detection is not configurable by combined_nms.')
+
+ with tf.name_scope(scope, 'CombinedNonMaxSuppression'):
+ (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_num_detections) = tf.image.combined_non_max_suppression(
+ boxes=boxes,
+ scores=scores,
+ max_output_size_per_class=max_size_per_class,
+ max_total_size=max_total_size,
+ iou_threshold=iou_thresh,
+ score_threshold=score_thresh,
+ pad_per_class=use_static_shapes)
+ # Not supported by combined_non_max_suppression.
+ batch_nmsed_masks = None
+ # Not supported by combined_non_max_suppression.
+ batch_nmsed_additional_fields = None
+ return (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_nmsed_masks, batch_nmsed_additional_fields,
+ batch_num_detections)
+
+ q = shape_utils.get_dim_as_int(boxes.shape[2])
+ num_classes = shape_utils.get_dim_as_int(scores.shape[2])
+ if q != 1 and q != num_classes:
+ raise ValueError('third dimension of boxes must be either 1 or equal '
+ 'to the third dimension of scores.')
+ if change_coordinate_frame and clip_window is None:
+ raise ValueError('if change_coordinate_frame is True, then a clip_window'
+ 'must be specified.')
+ original_masks = masks
+
+ # Create ordered dictionary using the sorted keys from
+ # additional fields to ensure getting the same key value assignment
+ # in _single_image_nms_fn(). The dictionary is thus a sorted version of
+ # additional_fields.
+ if additional_fields is None:
+ ordered_additional_fields = {}
+ else:
+ ordered_additional_fields = collections.OrderedDict(
+ sorted(additional_fields.items(), key=lambda item: item[0]))
+ del additional_fields
+ with tf.name_scope(scope, 'BatchMultiClassNonMaxSuppression'):
+ boxes_shape = boxes.shape
+ batch_size = shape_utils.get_dim_as_int(boxes_shape[0])
+ num_anchors = shape_utils.get_dim_as_int(boxes_shape[1])
+
+ if batch_size is None:
+ batch_size = tf.shape(boxes)[0]
+ if num_anchors is None:
+ num_anchors = tf.shape(boxes)[1]
+
+ # If num valid boxes aren't provided, create one and mark all boxes as
+ # valid.
+ if num_valid_boxes is None:
+ num_valid_boxes = tf.ones([batch_size], dtype=tf.int32) * num_anchors
+
+ # If masks aren't provided, create dummy masks so we can only have one copy
+ # of _single_image_nms_fn and discard the dummy masks after map_fn.
+ if masks is None:
+ masks_shape = tf.stack([batch_size, num_anchors, q, 1, 1])
+ masks = tf.zeros(masks_shape)
+
+ if clip_window is None:
+ clip_window = tf.stack([
+ tf.reduce_min(boxes[:, :, :, 0]),
+ tf.reduce_min(boxes[:, :, :, 1]),
+ tf.reduce_max(boxes[:, :, :, 2]),
+ tf.reduce_max(boxes[:, :, :, 3])
+ ])
+ if clip_window.shape.ndims == 1:
+ clip_window = tf.tile(tf.expand_dims(clip_window, 0), [batch_size, 1])
+
+ def _single_image_nms_fn(args):
+ """Runs NMS on a single image and returns padded output.
+
+ Args:
+ args: A list of tensors consisting of the following:
+ per_image_boxes - A [num_anchors, q, 4] float32 tensor containing
+ detections. If `q` is 1 then same boxes are used for all classes
+ otherwise, if `q` is equal to number of classes, class-specific
+ boxes are used.
+ per_image_scores - A [num_anchors, num_classes] float32 tensor
+ containing the scores for each of the `num_anchors` detections.
+ per_image_masks - A [num_anchors, q, mask_height, mask_width] float32
+ tensor containing box masks. `q` can be either number of classes
+ or 1 depending on whether a separate mask is predicted per class.
+ per_image_clip_window - A 1D float32 tensor of the form
+ [ymin, xmin, ymax, xmax] representing the window to clip the boxes
+ to.
+ per_image_additional_fields - (optional) A variable number of float32
+ tensors each with size [num_anchors, ...].
+ per_image_num_valid_boxes - A tensor of type `int32`. A 1-D tensor of
+ shape [batch_size] representing the number of valid boxes to be
+ considered for each image in the batch. This parameter allows for
+ ignoring zero paddings.
+
+ Returns:
+ 'nmsed_boxes': A [max_detections, 4] float32 tensor containing the
+ non-max suppressed boxes.
+ 'nmsed_scores': A [max_detections] float32 tensor containing the scores
+ for the boxes.
+ 'nmsed_classes': A [max_detections] float32 tensor containing the class
+ for boxes.
+ 'nmsed_masks': (optional) a [max_detections, mask_height, mask_width]
+ float32 tensor containing masks for each selected box. This is set to
+ None if input `masks` is None.
+ 'nmsed_additional_fields': (optional) A variable number of float32
+ tensors each with size [max_detections, ...] corresponding to the
+ input `per_image_additional_fields`.
+ 'num_detections': A [batch_size] int32 tensor indicating the number of
+ valid detections per batch item. Only the top num_detections[i]
+ entries in nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The
+ rest of the entries are zero paddings.
+ """
+ per_image_boxes = args[0]
+ per_image_scores = args[1]
+ per_image_masks = args[2]
+ per_image_clip_window = args[3]
+ # Make sure that the order of elements passed in args is aligned with
+ # the iteration order of ordered_additional_fields
+ per_image_additional_fields = {
+ key: value
+ for key, value in zip(ordered_additional_fields, args[4:-1])
+ }
+ per_image_num_valid_boxes = args[-1]
+ if use_static_shapes:
+ total_proposals = tf.shape(per_image_scores)
+ per_image_scores = tf.where(
+ tf.less(tf.range(total_proposals[0]), per_image_num_valid_boxes),
+ per_image_scores,
+ tf.fill(total_proposals, np.finfo('float32').min))
+ else:
+ per_image_boxes = tf.reshape(
+ tf.slice(per_image_boxes, 3 * [0],
+ tf.stack([per_image_num_valid_boxes, -1, -1])), [-1, q, 4])
+ per_image_scores = tf.reshape(
+ tf.slice(per_image_scores, [0, 0],
+ tf.stack([per_image_num_valid_boxes, -1])),
+ [-1, num_classes])
+ per_image_masks = tf.reshape(
+ tf.slice(per_image_masks, 4 * [0],
+ tf.stack([per_image_num_valid_boxes, -1, -1, -1])),
+ [-1, q, shape_utils.get_dim_as_int(per_image_masks.shape[2]),
+ shape_utils.get_dim_as_int(per_image_masks.shape[3])])
+ if per_image_additional_fields is not None:
+ for key, tensor in per_image_additional_fields.items():
+ additional_field_shape = tensor.get_shape()
+ additional_field_dim = len(additional_field_shape)
+ per_image_additional_fields[key] = tf.reshape(
+ tf.slice(
+ per_image_additional_fields[key],
+ additional_field_dim * [0],
+ tf.stack([per_image_num_valid_boxes] +
+ (additional_field_dim - 1) * [-1])), [-1] + [
+ shape_utils.get_dim_as_int(dim)
+ for dim in additional_field_shape[1:]
+ ])
+ if use_class_agnostic_nms:
+ nmsed_boxlist, num_valid_nms_boxes = class_agnostic_non_max_suppression(
+ per_image_boxes,
+ per_image_scores,
+ score_thresh,
+ iou_thresh,
+ max_classes_per_detection,
+ max_total_size,
+ clip_window=per_image_clip_window,
+ change_coordinate_frame=change_coordinate_frame,
+ masks=per_image_masks,
+ pad_to_max_output_size=use_static_shapes,
+ use_partitioned_nms=use_partitioned_nms,
+ additional_fields=per_image_additional_fields,
+ soft_nms_sigma=soft_nms_sigma)
+ else:
+ nmsed_boxlist, num_valid_nms_boxes = multiclass_non_max_suppression(
+ per_image_boxes,
+ per_image_scores,
+ score_thresh,
+ iou_thresh,
+ max_size_per_class,
+ max_total_size,
+ clip_window=per_image_clip_window,
+ change_coordinate_frame=change_coordinate_frame,
+ masks=per_image_masks,
+ pad_to_max_output_size=use_static_shapes,
+ use_partitioned_nms=use_partitioned_nms,
+ additional_fields=per_image_additional_fields,
+ soft_nms_sigma=soft_nms_sigma)
+
+ if not use_static_shapes:
+ nmsed_boxlist = box_list_ops.pad_or_clip_box_list(
+ nmsed_boxlist, max_total_size)
+ num_detections = num_valid_nms_boxes
+ nmsed_boxes = nmsed_boxlist.get()
+ nmsed_scores = nmsed_boxlist.get_field(fields.BoxListFields.scores)
+ nmsed_classes = nmsed_boxlist.get_field(fields.BoxListFields.classes)
+ nmsed_masks = nmsed_boxlist.get_field(fields.BoxListFields.masks)
+ nmsed_additional_fields = []
+ # Sorting is needed here to ensure that the values stored in
+ # nmsed_additional_fields are always kept in the same order
+ # across different execution runs.
+ for key in sorted(per_image_additional_fields.keys()):
+ nmsed_additional_fields.append(nmsed_boxlist.get_field(key))
+ return ([nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_masks] +
+ nmsed_additional_fields + [num_detections])
+
+ num_additional_fields = 0
+ if ordered_additional_fields:
+ num_additional_fields = len(ordered_additional_fields)
+ num_nmsed_outputs = 4 + num_additional_fields
+
+ if use_dynamic_map_fn:
+ map_fn = tf.map_fn
+ else:
+ map_fn = shape_utils.static_or_dynamic_map_fn
+
+ batch_outputs = map_fn(
+ _single_image_nms_fn,
+ elems=([boxes, scores, masks, clip_window] +
+ list(ordered_additional_fields.values()) + [num_valid_boxes]),
+ dtype=(num_nmsed_outputs * [tf.float32] + [tf.int32]),
+ parallel_iterations=parallel_iterations)
+
+ batch_nmsed_boxes = batch_outputs[0]
+ batch_nmsed_scores = batch_outputs[1]
+ batch_nmsed_classes = batch_outputs[2]
+ batch_nmsed_masks = batch_outputs[3]
+ batch_nmsed_values = batch_outputs[4:-1]
+
+ batch_nmsed_additional_fields = {}
+ if num_additional_fields > 0:
+ # Sort the keys to ensure arranging elements in same order as
+ # in _single_image_nms_fn.
+ batch_nmsed_keys = list(ordered_additional_fields.keys())
+ for i in range(len(batch_nmsed_keys)):
+ batch_nmsed_additional_fields[
+ batch_nmsed_keys[i]] = batch_nmsed_values[i]
+
+ batch_num_detections = batch_outputs[-1]
+
+ if original_masks is None:
+ batch_nmsed_masks = None
+
+ if not ordered_additional_fields:
+ batch_nmsed_additional_fields = None
+
+ return (batch_nmsed_boxes, batch_nmsed_scores, batch_nmsed_classes,
+ batch_nmsed_masks, batch_nmsed_additional_fields,
+ batch_num_detections)
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher.py
new file mode 100644
index 00000000..9bb7d658
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher.py
@@ -0,0 +1,61 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Provides functions to prefetch tensors to feed into models."""
+import tensorflow as tf
+
+
+def prefetch(tensor_dict, capacity):
+ """Creates a prefetch queue for tensors.
+
+ Creates a FIFO queue to asynchronously enqueue tensor_dicts and returns a
+ dequeue op that evaluates to a tensor_dict. This function is useful in
+ prefetching preprocessed tensors so that the data is readily available for
+ consumers.
+
+ Example input pipeline when you don't need batching:
+ ----------------------------------------------------
+ key, string_tensor = slim.parallel_reader.parallel_read(...)
+ tensor_dict = decoder.decode(string_tensor)
+ tensor_dict = preprocessor.preprocess(tensor_dict, ...)
+ prefetch_queue = prefetcher.prefetch(tensor_dict, capacity=20)
+ tensor_dict = prefetch_queue.dequeue()
+ outputs = Model(tensor_dict)
+ ...
+ ----------------------------------------------------
+
+ For input pipelines with batching, refer to core/batcher.py
+
+ Args:
+ tensor_dict: a dictionary of tensors to prefetch.
+ capacity: the size of the prefetch queue.
+
+ Returns:
+ a FIFO prefetcher queue
+ """
+ names = list(tensor_dict.keys())
+ dtypes = [t.dtype for t in tensor_dict.values()]
+ shapes = [t.get_shape() for t in tensor_dict.values()]
+ prefetch_queue = tf.PaddingFIFOQueue(capacity, dtypes=dtypes,
+ shapes=shapes,
+ names=names,
+ name='prefetch_queue')
+ enqueue_op = prefetch_queue.enqueue(tensor_dict)
+ tf.train.queue_runner.add_queue_runner(tf.train.queue_runner.QueueRunner(
+ prefetch_queue, [enqueue_op]))
+ tf.summary.scalar(
+ 'queue/%s/fraction_of_%d_full' % (prefetch_queue.name, capacity),
+ tf.cast(prefetch_queue.size(), dtype=tf.float32) * (1. / capacity))
+ return prefetch_queue
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher_test.py
new file mode 100644
index 00000000..83782d35
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/prefetcher_test.py
@@ -0,0 +1,106 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.prefetcher."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+import tensorflow as tf
+
+from object_detection.core import prefetcher
+
+slim = tf.contrib.slim
+
+
+class PrefetcherTest(tf.test.TestCase):
+
+ def test_prefetch_tensors_with_fully_defined_shapes(self):
+ with self.test_session() as sess:
+ batch_size = 10
+ image_size = 32
+ num_batches = 5
+ examples = tf.Variable(tf.constant(0, dtype=tf.int64))
+ counter = examples.count_up_to(num_batches)
+ image = tf.random_normal([batch_size, image_size,
+ image_size, 3],
+ dtype=tf.float32,
+ name='images')
+ label = tf.random_uniform([batch_size, 1], 0, 10,
+ dtype=tf.int32, name='labels')
+
+ prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
+ 'image': image,
+ 'label': label},
+ capacity=100)
+ tensor_dict = prefetch_queue.dequeue()
+
+ self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
+ [batch_size, image_size, image_size, 3])
+ self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
+ [batch_size, 1])
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ for _ in range(num_batches):
+ results = sess.run(tensor_dict)
+ self.assertEquals(results['image'].shape,
+ (batch_size, image_size, image_size, 3))
+ self.assertEquals(results['label'].shape, (batch_size, 1))
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(tensor_dict)
+
+ def test_prefetch_tensors_with_partially_defined_shapes(self):
+ with self.test_session() as sess:
+ batch_size = 10
+ image_size = 32
+ num_batches = 5
+ examples = tf.Variable(tf.constant(0, dtype=tf.int64))
+ counter = examples.count_up_to(num_batches)
+ image = tf.random_normal([batch_size,
+ tf.Variable(image_size),
+ tf.Variable(image_size), 3],
+ dtype=tf.float32,
+ name='image')
+ image.set_shape([batch_size, None, None, 3])
+ label = tf.random_uniform([batch_size, tf.Variable(1)], 0,
+ 10, dtype=tf.int32, name='label')
+ label.set_shape([batch_size, None])
+
+ prefetch_queue = prefetcher.prefetch(tensor_dict={'counter': counter,
+ 'image': image,
+ 'label': label},
+ capacity=100)
+ tensor_dict = prefetch_queue.dequeue()
+
+ self.assertAllEqual(tensor_dict['image'].get_shape().as_list(),
+ [batch_size, None, None, 3])
+ self.assertAllEqual(tensor_dict['label'].get_shape().as_list(),
+ [batch_size, None])
+
+ tf.initialize_all_variables().run()
+ with slim.queues.QueueRunners(sess):
+ for _ in range(num_batches):
+ results = sess.run(tensor_dict)
+ self.assertEquals(results['image'].shape,
+ (batch_size, image_size, image_size, 3))
+ self.assertEquals(results['label'].shape, (batch_size, 1))
+ with self.assertRaises(tf.errors.OutOfRangeError):
+ sess.run(tensor_dict)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor.py
new file mode 100644
index 00000000..1c74a585
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor.py
@@ -0,0 +1,4008 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Preprocess images and bounding boxes for detection.
+
+We perform two sets of operations in preprocessing stage:
+(a) operations that are applied to both training and testing data,
+(b) operations that are applied only to training data for the purpose of
+ data augmentation.
+
+A preprocessing function receives a set of inputs,
+e.g. an image and bounding boxes,
+performs an operation on them, and returns them.
+Some examples are: randomly cropping the image, randomly mirroring the image,
+ randomly changing the brightness, contrast, hue and
+ randomly jittering the bounding boxes.
+
+The preprocess function receives a tensor_dict which is a dictionary that maps
+different field names to their tensors. For example,
+tensor_dict[fields.InputDataFields.image] holds the image tensor.
+The image is a rank 4 tensor: [1, height, width, channels] with
+dtype=tf.float32. The groundtruth_boxes is a rank 2 tensor: [N, 4] where
+in each row there is a box with [ymin xmin ymax xmax].
+Boxes are in normalized coordinates meaning
+their coordinate values range in [0, 1]
+
+To preprocess multiple images with the same operations in cases where
+nondeterministic operations are used, a preprocessor_cache.PreprocessorCache
+object can be passed into the preprocess function or individual operations.
+All nondeterministic operations except random_jitter_boxes support caching.
+E.g.
+Let tensor_dict{1,2,3,4,5} be copies of the same inputs.
+Let preprocess_options contain nondeterministic operation(s) excluding
+random_jitter_boxes.
+
+cache1 = preprocessor_cache.PreprocessorCache()
+cache2 = preprocessor_cache.PreprocessorCache()
+a = preprocess(tensor_dict1, preprocess_options, preprocess_vars_cache=cache1)
+b = preprocess(tensor_dict2, preprocess_options, preprocess_vars_cache=cache1)
+c = preprocess(tensor_dict3, preprocess_options, preprocess_vars_cache=cache2)
+d = preprocess(tensor_dict4, preprocess_options, preprocess_vars_cache=cache2)
+e = preprocess(tensor_dict5, preprocess_options)
+
+Then correspondings tensors of object pairs (a,b) and (c,d)
+are guaranteed to be equal element-wise, but the equality of any other object
+pair cannot be determined.
+
+Important Note: In tensor_dict, images is a rank 4 tensor, but preprocessing
+functions receive a rank 3 tensor for processing the image. Thus, inside the
+preprocess function we squeeze the image to become a rank 3 tensor and then
+we pass it to the functions. At the end of the preprocess we expand the image
+back to rank 4.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import functools
+import inspect
+import sys
+
+import six
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from tensorflow.python.ops import control_flow_ops
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import keypoint_ops
+from object_detection.core import preprocessor_cache
+from object_detection.core import standard_fields as fields
+from object_detection.utils import autoaugment_utils
+from object_detection.utils import patch_ops
+from object_detection.utils import shape_utils
+
+
+def _apply_with_random_selector(x,
+ func,
+ num_cases,
+ preprocess_vars_cache=None,
+ key=''):
+ """Computes func(x, sel), with sel sampled from [0...num_cases-1].
+
+ If both preprocess_vars_cache AND key are the same between two calls, sel will
+ be the same value in both calls.
+
+ Args:
+ x: input Tensor.
+ func: Python function to apply.
+ num_cases: Python int32, number of cases to sample sel from.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: variable identifier for preprocess_vars_cache.
+
+ Returns:
+ The result of func(x, sel), where func receives the value of the
+ selector as a python integer, but sel is sampled dynamically.
+ """
+ generator_func = functools.partial(
+ tf.random_uniform, [], maxval=num_cases, dtype=tf.int32)
+ rand_sel = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.SELECTOR,
+ preprocess_vars_cache, key)
+
+ # Pass the real x only to one of the func calls.
+ return control_flow_ops.merge([func(
+ control_flow_ops.switch(x, tf.equal(rand_sel, case))[1], case)
+ for case in range(num_cases)])[0]
+
+
+def _apply_with_random_selector_tuples(x,
+ func,
+ num_cases,
+ preprocess_vars_cache=None,
+ key=''):
+ """Computes func(x, sel), with sel sampled from [0...num_cases-1].
+
+ If both preprocess_vars_cache AND key are the same between two calls, sel will
+ be the same value in both calls.
+
+ Args:
+ x: A tuple of input tensors.
+ func: Python function to apply.
+ num_cases: Python int32, number of cases to sample sel from.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: variable identifier for preprocess_vars_cache.
+
+ Returns:
+ The result of func(x, sel), where func receives the value of the
+ selector as a python integer, but sel is sampled dynamically.
+ """
+ num_inputs = len(x)
+ generator_func = functools.partial(
+ tf.random_uniform, [], maxval=num_cases, dtype=tf.int32)
+ rand_sel = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.SELECTOR_TUPLES,
+ preprocess_vars_cache, key)
+
+ # Pass the real x only to one of the func calls.
+ tuples = [list() for t in x]
+ for case in range(num_cases):
+ new_x = [control_flow_ops.switch(t, tf.equal(rand_sel, case))[1] for t in x]
+ output = func(tuple(new_x), case)
+ for j in range(num_inputs):
+ tuples[j].append(output[j])
+
+ for i in range(num_inputs):
+ tuples[i] = control_flow_ops.merge(tuples[i])[0]
+ return tuple(tuples)
+
+
+def _get_or_create_preprocess_rand_vars(generator_func,
+ function_id,
+ preprocess_vars_cache,
+ key=''):
+ """Returns a tensor stored in preprocess_vars_cache or using generator_func.
+
+ If the tensor was previously generated and appears in the PreprocessorCache,
+ the previously generated tensor will be returned. Otherwise, a new tensor
+ is generated using generator_func and stored in the cache.
+
+ Args:
+ generator_func: A 0-argument function that generates a tensor.
+ function_id: identifier for the preprocessing function used.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+ key: identifier for the variable stored.
+ Returns:
+ The generated tensor.
+ """
+ if preprocess_vars_cache is not None:
+ var = preprocess_vars_cache.get(function_id, key)
+ if var is None:
+ var = generator_func()
+ preprocess_vars_cache.update(function_id, key, var)
+ else:
+ var = generator_func()
+ return var
+
+
+def _random_integer(minval, maxval, seed):
+ """Returns a random 0-D tensor between minval and maxval.
+
+ Args:
+ minval: minimum value of the random tensor.
+ maxval: maximum value of the random tensor.
+ seed: random seed.
+
+ Returns:
+ A random 0-D tensor between minval and maxval.
+ """
+ return tf.random_uniform(
+ [], minval=minval, maxval=maxval, dtype=tf.int32, seed=seed)
+
+
+# TODO(mttang): This method is needed because the current
+# tf.image.rgb_to_grayscale method does not support quantization. Replace with
+# tf.image.rgb_to_grayscale after quantization support is added.
+def _rgb_to_grayscale(images, name=None):
+ """Converts one or more images from RGB to Grayscale.
+
+ Outputs a tensor of the same `DType` and rank as `images`. The size of the
+ last dimension of the output is 1, containing the Grayscale value of the
+ pixels.
+
+ Args:
+ images: The RGB tensor to convert. Last dimension must have size 3 and
+ should contain RGB values.
+ name: A name for the operation (optional).
+
+ Returns:
+ The converted grayscale image(s).
+ """
+ with tf.name_scope(name, 'rgb_to_grayscale', [images]) as name:
+ images = tf.convert_to_tensor(images, name='images')
+ # Remember original dtype to so we can convert back if needed
+ orig_dtype = images.dtype
+ flt_image = tf.image.convert_image_dtype(images, tf.float32)
+
+ # Reference for converting between RGB and grayscale.
+ # https://en.wikipedia.org/wiki/Luma_%28video%29
+ rgb_weights = [0.2989, 0.5870, 0.1140]
+ rank_1 = tf.expand_dims(tf.rank(images) - 1, 0)
+ gray_float = tf.reduce_sum(
+ flt_image * rgb_weights, rank_1, keep_dims=True)
+ gray_float.set_shape(images.get_shape()[:-1].concatenate([1]))
+ return tf.image.convert_image_dtype(gray_float, orig_dtype, name=name)
+
+
+def normalize_image(image, original_minval, original_maxval, target_minval,
+ target_maxval):
+ """Normalizes pixel values in the image.
+
+ Moves the pixel values from the current [original_minval, original_maxval]
+ range to a the [target_minval, target_maxval] range.
+
+ Args:
+ image: rank 3 float32 tensor containing 1
+ image -> [height, width, channels].
+ original_minval: current image minimum value.
+ original_maxval: current image maximum value.
+ target_minval: target image minimum value.
+ target_maxval: target image maximum value.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('NormalizeImage', values=[image]):
+ original_minval = float(original_minval)
+ original_maxval = float(original_maxval)
+ target_minval = float(target_minval)
+ target_maxval = float(target_maxval)
+ image = tf.cast(image, dtype=tf.float32)
+ image = tf.subtract(image, original_minval)
+ image = tf.multiply(image, (target_maxval - target_minval) /
+ (original_maxval - original_minval))
+ image = tf.add(image, target_minval)
+ return image
+
+
+def retain_boxes_above_threshold(boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ threshold=0.0):
+ """Retains boxes whose label weight is above a given threshold.
+
+ If the label weight for a box is missing (represented by NaN), the box is
+ retained. The boxes that don't pass the threshold will not appear in the
+ returned tensor.
+
+ Args:
+ boxes: float32 tensor of shape [num_instance, 4] representing boxes
+ location in normalized coordinates.
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ label_weights: float32 tensor of shape [num_instance] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instance] representing the
+ confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ threshold: scalar python float.
+
+ Returns:
+ retained_boxes: [num_retained_instance, 4]
+ retianed_labels: [num_retained_instance]
+ retained_label_weights: [num_retained_instance]
+
+ If multiclass_scores, masks, or keypoints are not None, the function also
+ returns:
+
+ retained_multiclass_scores: [num_retained_instance, num_classes]
+ retained_masks: [num_retained_instance, height, width]
+ retained_keypoints: [num_retained_instance, num_keypoints, 2]
+ """
+ with tf.name_scope('RetainBoxesAboveThreshold',
+ values=[boxes, labels, label_weights]):
+ indices = tf.where(
+ tf.logical_or(label_weights > threshold, tf.is_nan(label_weights)))
+ indices = tf.squeeze(indices, axis=1)
+ retained_boxes = tf.gather(boxes, indices)
+ retained_labels = tf.gather(labels, indices)
+ retained_label_weights = tf.gather(label_weights, indices)
+ result = [retained_boxes, retained_labels, retained_label_weights]
+
+ if label_confidences is not None:
+ retained_label_confidences = tf.gather(label_confidences, indices)
+ result.append(retained_label_confidences)
+
+ if multiclass_scores is not None:
+ retained_multiclass_scores = tf.gather(multiclass_scores, indices)
+ result.append(retained_multiclass_scores)
+
+ if masks is not None:
+ retained_masks = tf.gather(masks, indices)
+ result.append(retained_masks)
+
+ if keypoints is not None:
+ retained_keypoints = tf.gather(keypoints, indices)
+ result.append(retained_keypoints)
+
+ return result
+
+
+def drop_label_probabilistically(boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ dropped_label=None,
+ drop_probability=0.0,
+ seed=None):
+ """Drops boxes of a certain label with probability drop_probability.
+
+ Boxes of the label dropped_label will not appear in the returned tensor.
+
+ Args:
+ boxes: float32 tensor of shape [num_instance, 4] representing boxes
+ location in normalized coordinates.
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ label_weights: float32 tensor of shape [num_instance] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instance] representing the
+ confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ dropped_label: int32 id of label to drop.
+ drop_probability: float32 probability of dropping a label.
+ seed: random seed.
+
+ Returns:
+ retained_boxes: [num_retained_instance, 4]
+ retianed_labels: [num_retained_instance]
+ retained_label_weights: [num_retained_instance]
+
+ If multiclass_scores, masks, or keypoints are not None, the function also
+ returns:
+
+ retained_multiclass_scores: [num_retained_instance, num_classes]
+ retained_masks: [num_retained_instance, height, width]
+ retained_keypoints: [num_retained_instance, num_keypoints, 2]
+ """
+ with tf.name_scope('DropLabelProbabilistically',
+ values=[boxes, labels]):
+ indices = tf.where(
+ tf.logical_or(
+ tf.random_uniform(tf.shape(labels), seed=seed) > drop_probability,
+ tf.not_equal(labels, dropped_label)))
+ indices = tf.squeeze(indices, axis=1)
+
+ retained_boxes = tf.gather(boxes, indices)
+ retained_labels = tf.gather(labels, indices)
+ retained_label_weights = tf.gather(label_weights, indices)
+ result = [retained_boxes, retained_labels, retained_label_weights]
+
+ if label_confidences is not None:
+ retained_label_confidences = tf.gather(label_confidences, indices)
+ result.append(retained_label_confidences)
+
+ if multiclass_scores is not None:
+ retained_multiclass_scores = tf.gather(multiclass_scores, indices)
+ result.append(retained_multiclass_scores)
+
+ if masks is not None:
+ retained_masks = tf.gather(masks, indices)
+ result.append(retained_masks)
+
+ if keypoints is not None:
+ retained_keypoints = tf.gather(keypoints, indices)
+ result.append(retained_keypoints)
+
+ return result
+
+
+def remap_labels(labels,
+ original_labels=None,
+ new_label=None):
+ """Remaps labels that have an id in original_labels to new_label.
+
+ Args:
+ labels: rank 1 int32 tensor of shape [num_instance] containing the object
+ classes.
+ original_labels: int list of original labels that should be mapped from.
+ new_label: int label to map to
+ Returns:
+ Remapped labels
+ """
+ new_labels = labels
+ for original_label in original_labels:
+ change = tf.where(
+ tf.equal(new_labels, original_label),
+ tf.add(tf.zeros_like(new_labels), new_label - original_label),
+ tf.zeros_like(new_labels))
+ new_labels = tf.add(
+ new_labels,
+ change)
+ new_labels = tf.reshape(new_labels, tf.shape(labels))
+ return new_labels
+
+
+def _flip_boxes_left_right(boxes):
+ """Left-right flip the boxes.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Flipped boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ flipped_xmin = tf.subtract(1.0, xmax)
+ flipped_xmax = tf.subtract(1.0, xmin)
+ flipped_boxes = tf.concat([ymin, flipped_xmin, ymax, flipped_xmax], 1)
+ return flipped_boxes
+
+
+def _flip_boxes_up_down(boxes):
+ """Up-down flip the boxes.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Flipped boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ flipped_ymin = tf.subtract(1.0, ymax)
+ flipped_ymax = tf.subtract(1.0, ymin)
+ flipped_boxes = tf.concat([flipped_ymin, xmin, flipped_ymax, xmax], 1)
+ return flipped_boxes
+
+
+def _rot90_boxes(boxes):
+ """Rotate boxes counter-clockwise by 90 degrees.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+
+ Returns:
+ Rotated boxes.
+ """
+ ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)
+ rotated_ymin = tf.subtract(1.0, xmax)
+ rotated_ymax = tf.subtract(1.0, xmin)
+ rotated_xmin = ymin
+ rotated_xmax = ymax
+ rotated_boxes = tf.concat(
+ [rotated_ymin, rotated_xmin, rotated_ymax, rotated_xmax], 1)
+ return rotated_boxes
+
+
+def _flip_masks_left_right(masks):
+ """Left-right flip masks.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ flipped masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ return masks[:, :, ::-1]
+
+
+def _flip_masks_up_down(masks):
+ """Up-down flip masks.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ flipped masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ return masks[:, ::-1, :]
+
+
+def _rot90_masks(masks):
+ """Rotate masks counter-clockwise by 90 degrees.
+
+ Args:
+ masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+
+ Returns:
+ rotated masks: rank 3 float32 tensor with shape
+ [num_instances, height, width] representing instance masks.
+ """
+ masks = tf.transpose(masks, [0, 2, 1])
+ return masks[:, ::-1, :]
+
+
+def random_horizontal_flip(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ keypoint_flip_permutation=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly flips the image and detections horizontally.
+
+ The probability of flipping the image is 50%.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ keypoint_flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, keypoints, and keypoint_flip_permutation are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: if keypoints are provided but keypoint_flip_permutation is not.
+ """
+
+ def _flip_image(image):
+ # flip image
+ image_flipped = tf.image.flip_left_right(image)
+ return image_flipped
+
+ if keypoints is not None and keypoint_flip_permutation is None:
+ raise ValueError(
+ 'keypoints are provided but keypoints_flip_permutation is not provided')
+
+ with tf.name_scope('RandomHorizontalFlip', values=[image, boxes]):
+ result = []
+ # random variable defining whether to do flip or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_flip_random = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.HORIZONTAL_FLIP,
+ preprocess_vars_cache)
+ do_a_flip_random = tf.greater(do_a_flip_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_flip_random, lambda: _flip_image(image), lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_flip_random, lambda: _flip_boxes_left_right(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_flip_random, lambda: _flip_masks_left_right(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None and keypoint_flip_permutation is not None:
+ permutation = keypoint_flip_permutation
+ keypoints = tf.cond(
+ do_a_flip_random,
+ lambda: keypoint_ops.flip_horizontal(keypoints, 0.5, permutation),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_vertical_flip(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ keypoint_flip_permutation=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly flips the image and detections vertically.
+
+ The probability of flipping the image is 50%.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ keypoint_flip_permutation: rank 1 int32 tensor containing the keypoint flip
+ permutation.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, keypoints, and keypoint_flip_permutation are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: if keypoints are provided but keypoint_flip_permutation is not.
+ """
+
+ def _flip_image(image):
+ # flip image
+ image_flipped = tf.image.flip_up_down(image)
+ return image_flipped
+
+ if keypoints is not None and keypoint_flip_permutation is None:
+ raise ValueError(
+ 'keypoints are provided but keypoints_flip_permutation is not provided')
+
+ with tf.name_scope('RandomVerticalFlip', values=[image, boxes]):
+ result = []
+ # random variable defining whether to do flip or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_flip_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.VERTICAL_FLIP,
+ preprocess_vars_cache)
+ do_a_flip_random = tf.greater(do_a_flip_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_flip_random, lambda: _flip_image(image), lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_flip_random, lambda: _flip_boxes_up_down(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_flip_random, lambda: _flip_masks_up_down(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None and keypoint_flip_permutation is not None:
+ permutation = keypoint_flip_permutation
+ keypoints = tf.cond(
+ do_a_flip_random,
+ lambda: keypoint_ops.flip_vertical(keypoints, 0.5, permutation),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_rotation90(image,
+ boxes=None,
+ masks=None,
+ keypoints=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly rotates the image and detections 90 degrees counter-clockwise.
+
+ The probability of rotating the image is 50%. This can be combined with
+ random_horizontal_flip and random_vertical_flip to produce an output with a
+ uniform distribution of the eight possible 90 degree rotation / reflection
+ combinations.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels].
+ boxes: (optional) rank 2 float32 tensor with shape [N, 4]
+ containing the bounding boxes.
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ seed: random seed
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ If boxes, masks, and keypoints, are not None,
+ the function also returns the following tensors.
+
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def _rot90_image(image):
+ # flip image
+ image_rotated = tf.image.rot90(image)
+ return image_rotated
+
+ with tf.name_scope('RandomRotation90', values=[image, boxes]):
+ result = []
+
+ # random variable defining whether to rotate by 90 degrees or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_rot90_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.ROTATION90,
+ preprocess_vars_cache)
+ do_a_rot90_random = tf.greater(do_a_rot90_random, 0.5)
+
+ # flip image
+ image = tf.cond(do_a_rot90_random, lambda: _rot90_image(image),
+ lambda: image)
+ result.append(image)
+
+ # flip boxes
+ if boxes is not None:
+ boxes = tf.cond(do_a_rot90_random, lambda: _rot90_boxes(boxes),
+ lambda: boxes)
+ result.append(boxes)
+
+ # flip masks
+ if masks is not None:
+ masks = tf.cond(do_a_rot90_random, lambda: _rot90_masks(masks),
+ lambda: masks)
+ result.append(masks)
+
+ # flip keypoints
+ if keypoints is not None:
+ keypoints = tf.cond(
+ do_a_rot90_random,
+ lambda: keypoint_ops.rot90(keypoints),
+ lambda: keypoints)
+ result.append(keypoints)
+
+ return tuple(result)
+
+
+def random_pixel_value_scale(image,
+ minval=0.9,
+ maxval=1.1,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Scales each value in the pixels of the image.
+
+ This function scales each pixel independent of the other ones.
+ For each value in image tensor, draws a random number between
+ minval and maxval and multiples the values with them.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ minval: lower ratio of scaling pixel values.
+ maxval: upper ratio of scaling pixel values.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomPixelValueScale', values=[image]):
+ generator_func = functools.partial(
+ tf.random_uniform, tf.shape(image),
+ minval=minval, maxval=maxval,
+ dtype=tf.float32, seed=seed)
+ color_coef = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.PIXEL_VALUE_SCALE,
+ preprocess_vars_cache)
+
+ image = tf.multiply(image, color_coef)
+ image = tf.clip_by_value(image, 0.0, 255.0)
+
+ return image
+
+
+def random_image_scale(image,
+ masks=None,
+ min_scale_ratio=0.5,
+ max_scale_ratio=2.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Scales the image size.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels].
+ masks: (optional) rank 3 float32 tensor containing masks with
+ size [height, width, num_masks]. The value is set to None if there are no
+ masks.
+ min_scale_ratio: minimum scaling ratio.
+ max_scale_ratio: maximum scaling ratio.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ masks: If masks is not none, resized masks which are the same rank as input
+ masks will be returned.
+ """
+ with tf.name_scope('RandomImageScale', values=[image]):
+ result = []
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ generator_func = functools.partial(
+ tf.random_uniform, [],
+ minval=min_scale_ratio, maxval=max_scale_ratio,
+ dtype=tf.float32, seed=seed)
+ size_coef = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.IMAGE_SCALE,
+ preprocess_vars_cache)
+
+ image_newysize = tf.cast(
+ tf.multiply(tf.cast(image_height, dtype=tf.float32), size_coef),
+ dtype=tf.int32)
+ image_newxsize = tf.cast(
+ tf.multiply(tf.cast(image_width, dtype=tf.float32), size_coef),
+ dtype=tf.int32)
+ image = tf.image.resize_images(
+ image, [image_newysize, image_newxsize], align_corners=True)
+ result.append(image)
+ if masks is not None:
+ masks = tf.image.resize_images(
+ masks, [image_newysize, image_newxsize],
+ method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
+ align_corners=True)
+ result.append(masks)
+ return tuple(result)
+
+
+def _augment_only_rgb_channels(image, augment_function):
+ """Augments only the RGB slice of an image with additional channels."""
+ rgb_slice = image[:, :, :3]
+ augmented_rgb_slice = augment_function(rgb_slice)
+ image = tf.concat([augmented_rgb_slice, image[:, :, 3:]], -1)
+ return image
+
+
+def random_rgb_to_gray(image,
+ probability=0.1,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Changes the image from RGB to Grayscale with the given probability.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ probability: the probability of returning a grayscale image.
+ The probability should be a number between [0, 1].
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ def _image_to_gray(image):
+ image_gray1 = _rgb_to_grayscale(image)
+ image_gray3 = tf.image.grayscale_to_rgb(image_gray1)
+ return image_gray3
+
+ with tf.name_scope('RandomRGBtoGray', values=[image]):
+ # random variable defining whether to change to grayscale or not
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_gray_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.RGB_TO_GRAY,
+ preprocess_vars_cache)
+
+ image = tf.cond(
+ tf.greater(do_gray_random, probability), lambda: image,
+ lambda: _augment_only_rgb_channels(image, _image_to_gray))
+
+ return image
+
+
+def random_adjust_brightness(image,
+ max_delta=0.2,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts brightness.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ max_delta: how much to change the brightness. A value between [0, 1).
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ boxes: boxes which is the same shape as input boxes.
+ """
+ with tf.name_scope('RandomAdjustBrightness', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ -max_delta, max_delta, seed=seed)
+ delta = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_BRIGHTNESS,
+ preprocess_vars_cache)
+
+ def _adjust_brightness(image):
+ image = tf.image.adjust_brightness(image / 255, delta) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+
+ image = _augment_only_rgb_channels(image, _adjust_brightness)
+ return image
+
+
+def random_adjust_contrast(image,
+ min_delta=0.8,
+ max_delta=1.25,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts contrast.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ min_delta: see max_delta.
+ max_delta: how much to change the contrast. Contrast will change with a
+ value between min_delta and max_delta. This value will be
+ multiplied to the current contrast of the image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustContrast', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_delta, max_delta, seed=seed)
+ contrast_factor = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_CONTRAST,
+ preprocess_vars_cache)
+
+ def _adjust_contrast(image):
+ image = tf.image.adjust_contrast(image / 255, contrast_factor) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_contrast)
+ return image
+
+
+def random_adjust_hue(image,
+ max_delta=0.02,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts hue.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ max_delta: change hue randomly with a value between 0 and max_delta.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustHue', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ -max_delta, max_delta, seed=seed)
+ delta = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.ADJUST_HUE,
+ preprocess_vars_cache)
+ def _adjust_hue(image):
+ image = tf.image.adjust_hue(image / 255, delta) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_hue)
+ return image
+
+
+def random_adjust_saturation(image,
+ min_delta=0.8,
+ max_delta=1.25,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adjusts saturation.
+
+ Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ min_delta: see max_delta.
+ max_delta: how much to change the saturation. Saturation will change with a
+ value between min_delta and max_delta. This value will be
+ multiplied to the current saturation of the image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ with tf.name_scope('RandomAdjustSaturation', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_delta, max_delta, seed=seed)
+ saturation_factor = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADJUST_SATURATION,
+ preprocess_vars_cache)
+ def _adjust_saturation(image):
+ image = tf.image.adjust_saturation(image / 255, saturation_factor) * 255
+ image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=255.0)
+ return image
+ image = _augment_only_rgb_channels(image, _adjust_saturation)
+ return image
+
+
+def random_distort_color(image, color_ordering=0, preprocess_vars_cache=None):
+ """Randomly distorts color.
+
+ Randomly distorts color using a combination of brightness, hue, contrast and
+ saturation changes. Makes sure the output image is still between 0 and 255.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ color_ordering: Python int, a type of distortion (valid values: 0, 1).
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+
+ Raises:
+ ValueError: if color_ordering is not in {0, 1}.
+ """
+ with tf.name_scope('RandomDistortColor', values=[image]):
+ if color_ordering == 0:
+ image = random_adjust_brightness(
+ image, max_delta=32. / 255.,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_saturation(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_hue(
+ image, max_delta=0.2,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_contrast(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ elif color_ordering == 1:
+ image = random_adjust_brightness(
+ image, max_delta=32. / 255.,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_contrast(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_saturation(
+ image, min_delta=0.5, max_delta=1.5,
+ preprocess_vars_cache=preprocess_vars_cache)
+ image = random_adjust_hue(
+ image, max_delta=0.2,
+ preprocess_vars_cache=preprocess_vars_cache)
+ else:
+ raise ValueError('color_ordering must be in {0, 1}')
+ return image
+
+
+def random_jitter_boxes(boxes, ratio=0.05, seed=None):
+ """Randomly jitter boxes in image.
+
+ Args:
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ ratio: The ratio of the box width and height that the corners can jitter.
+ For example if the width is 100 pixels and ratio is 0.05,
+ the corners can jitter up to 5 pixels in the x direction.
+ seed: random seed.
+
+ Returns:
+ boxes: boxes which is the same shape as input boxes.
+ """
+ def random_jitter_box(box, ratio, seed):
+ """Randomly jitter box.
+
+ Args:
+ box: bounding box [1, 1, 4].
+ ratio: max ratio between jittered box and original box,
+ a number between [0, 0.5].
+ seed: random seed.
+
+ Returns:
+ jittered_box: jittered box.
+ """
+ rand_numbers = tf.random_uniform(
+ [1, 1, 4], minval=-ratio, maxval=ratio, dtype=tf.float32, seed=seed)
+ box_width = tf.subtract(box[0, 0, 3], box[0, 0, 1])
+ box_height = tf.subtract(box[0, 0, 2], box[0, 0, 0])
+ hw_coefs = tf.stack([box_height, box_width, box_height, box_width])
+ hw_rand_coefs = tf.multiply(hw_coefs, rand_numbers)
+ jittered_box = tf.add(box, hw_rand_coefs)
+ jittered_box = tf.clip_by_value(jittered_box, 0.0, 1.0)
+ return jittered_box
+
+ with tf.name_scope('RandomJitterBoxes', values=[boxes]):
+ # boxes are [N, 4]. Lets first make them [N, 1, 1, 4]
+ boxes_shape = tf.shape(boxes)
+ boxes = tf.expand_dims(boxes, 1)
+ boxes = tf.expand_dims(boxes, 2)
+
+ distorted_boxes = tf.map_fn(
+ lambda x: random_jitter_box(x, ratio, seed), boxes, dtype=tf.float32)
+
+ distorted_boxes = tf.reshape(distorted_boxes, boxes_shape)
+
+ return distorted_boxes
+
+
+def _strict_random_crop_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ preprocess_vars_cache=None):
+ """Performs random crop.
+
+ Note: Keypoint coordinates that are outside the crop will be set to NaN, which
+ is consistent with the original keypoint encoding for non-existing keypoints.
+ This function always crops the image and is supposed to be used by
+ `random_crop_image` function which sometimes returns the image unchanged.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ with tf.name_scope('RandomCropImage', values=[image, boxes]):
+ image_shape = tf.shape(image)
+
+ # boxes are [N, 4]. Lets first make them [N, 1, 4].
+ boxes_expanded = tf.expand_dims(
+ tf.clip_by_value(
+ boxes, clip_value_min=0.0, clip_value_max=1.0), 1)
+
+ generator_func = functools.partial(
+ tf.image.sample_distorted_bounding_box,
+ image_shape,
+ bounding_boxes=boxes_expanded,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ max_attempts=100,
+ use_image_if_no_bounding_boxes=True)
+
+ # for ssd cropping, each value of min_object_covered has its own
+ # cached random variable
+ sample_distorted_bounding_box = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.STRICT_CROP_IMAGE,
+ preprocess_vars_cache, key=min_object_covered)
+
+ im_box_begin, im_box_size, im_box = sample_distorted_bounding_box
+
+ new_image = tf.slice(image, im_box_begin, im_box_size)
+ new_image.set_shape([None, None, image.get_shape()[2]])
+
+ # [1, 4]
+ im_box_rank2 = tf.squeeze(im_box, axis=[0])
+ # [4]
+ im_box_rank1 = tf.squeeze(im_box)
+
+ boxlist = box_list.BoxList(boxes)
+ boxlist.add_field('labels', labels)
+
+ if label_weights is not None:
+ boxlist.add_field('label_weights', label_weights)
+
+ if label_confidences is not None:
+ boxlist.add_field('label_confidences', label_confidences)
+
+ if multiclass_scores is not None:
+ boxlist.add_field('multiclass_scores', multiclass_scores)
+
+ im_boxlist = box_list.BoxList(im_box_rank2)
+
+ # remove boxes that are outside cropped image
+ boxlist, inside_window_ids = box_list_ops.prune_completely_outside_window(
+ boxlist, im_box_rank1)
+
+ # remove boxes that are outside image
+ overlapping_boxlist, keep_ids = box_list_ops.prune_non_overlapping_boxes(
+ boxlist, im_boxlist, overlap_thresh)
+
+ # change the coordinate of the remaining boxes
+ new_labels = overlapping_boxlist.get_field('labels')
+ new_boxlist = box_list_ops.change_coordinate_frame(overlapping_boxlist,
+ im_box_rank1)
+ new_boxes = new_boxlist.get()
+ if clip_boxes:
+ new_boxes = tf.clip_by_value(
+ new_boxes, clip_value_min=0.0, clip_value_max=1.0)
+
+ result = [new_image, new_boxes, new_labels]
+
+ if label_weights is not None:
+ new_label_weights = overlapping_boxlist.get_field('label_weights')
+ result.append(new_label_weights)
+
+ if label_confidences is not None:
+ new_label_confidences = overlapping_boxlist.get_field('label_confidences')
+ result.append(new_label_confidences)
+
+ if multiclass_scores is not None:
+ new_multiclass_scores = overlapping_boxlist.get_field('multiclass_scores')
+ result.append(new_multiclass_scores)
+
+ if masks is not None:
+ masks_of_boxes_inside_window = tf.gather(masks, inside_window_ids)
+ masks_of_boxes_completely_inside_window = tf.gather(
+ masks_of_boxes_inside_window, keep_ids)
+ masks_box_begin = [0, im_box_begin[0], im_box_begin[1]]
+ masks_box_size = [-1, im_box_size[0], im_box_size[1]]
+ new_masks = tf.slice(
+ masks_of_boxes_completely_inside_window,
+ masks_box_begin, masks_box_size)
+ result.append(new_masks)
+
+ if keypoints is not None:
+ keypoints_of_boxes_inside_window = tf.gather(keypoints, inside_window_ids)
+ keypoints_of_boxes_completely_inside_window = tf.gather(
+ keypoints_of_boxes_inside_window, keep_ids)
+ new_keypoints = keypoint_ops.change_coordinate_frame(
+ keypoints_of_boxes_completely_inside_window, im_box_rank1)
+ if clip_boxes:
+ new_keypoints = keypoint_ops.prune_outside_window(new_keypoints,
+ [0.0, 0.0, 1.0, 1.0])
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_crop_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops the image.
+
+ Given the input image and its bounding boxes, this op randomly
+ crops a subimage. Given a user-provided set of input constraints,
+ the crop window is resampled until it satisfies these constraints.
+ If within 100 trials it is unable to find a valid crop, the original
+ image is returned. See the Args section for a description of the input
+ constraints. Both input boxes and returned Boxes are in normalized
+ form (e.g., lie in the unit square [0, 1]).
+ This function will return the original image with probability random_coef.
+
+ Note: Keypoint coordinates that are outside the crop will be set to NaN, which
+ is consistent with the original keypoint encoding for non-existing keypoints.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances].
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def strict_random_crop_image_fn():
+ return _strict_random_crop_image(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ # avoids tf.cond to make faster RCNN training on borg. See b/140057645.
+ if random_coef < sys.float_info.min:
+ result = strict_random_crop_image_fn()
+ else:
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_a_crop_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.CROP_IMAGE,
+ preprocess_vars_cache)
+ do_a_crop_random = tf.greater(do_a_crop_random, random_coef)
+
+ outputs = [image, boxes, labels]
+
+ if label_weights is not None:
+ outputs.append(label_weights)
+ if label_confidences is not None:
+ outputs.append(label_confidences)
+ if multiclass_scores is not None:
+ outputs.append(multiclass_scores)
+ if masks is not None:
+ outputs.append(masks)
+ if keypoints is not None:
+ outputs.append(keypoints)
+
+ result = tf.cond(do_a_crop_random, strict_random_crop_image_fn,
+ lambda: tuple(outputs))
+ return result
+
+
+def random_pad_image(image,
+ boxes,
+ keypoints=None,
+ min_image_size=None,
+ max_image_size=None,
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly pads the image.
+
+ This function randomly pads the image with zeros. The final size of the
+ padded image will be between min_image_size and max_image_size.
+ if min_image_size is smaller than the input image size, min_image_size will
+ be set to the input image size. The same for max_image_size. The input image
+ will be located at a uniformly random location inside the padded image.
+ The relative location of the boxes to the original image will remain the same.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [N, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+ min_image_size: a tensor of size [min_height, min_width], type tf.int32.
+ If passed as None, will be set to image size
+ [height, width].
+ max_image_size: a tensor of size [max_height, max_width], type tf.int32.
+ If passed as None, will be set to twice the
+ image [height * 2, width * 2].
+ pad_color: padding color. A rank 1 tensor of [channels] with dtype=
+ tf.float32. if set as None, it will be set to average color of
+ the input image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+
+ if keypoints is not None, the function also returns:
+ keypoints: rank 3 float32 tensor with shape [N, num_keypoints, 2]
+ """
+ if pad_color is None:
+ pad_color = tf.reduce_mean(image, axis=[0, 1])
+
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+
+ if max_image_size is None:
+ max_image_size = tf.stack([image_height * 2, image_width * 2])
+ max_image_size = tf.maximum(max_image_size,
+ tf.stack([image_height, image_width]))
+
+ if min_image_size is None:
+ min_image_size = tf.stack([image_height, image_width])
+ min_image_size = tf.maximum(min_image_size,
+ tf.stack([image_height, image_width]))
+
+ target_height = tf.cond(
+ max_image_size[0] > min_image_size[0],
+ lambda: _random_integer(min_image_size[0], max_image_size[0], seed),
+ lambda: max_image_size[0])
+
+ target_width = tf.cond(
+ max_image_size[1] > min_image_size[1],
+ lambda: _random_integer(min_image_size[1], max_image_size[1], seed),
+ lambda: max_image_size[1])
+
+ offset_height = tf.cond(
+ target_height > image_height,
+ lambda: _random_integer(0, target_height - image_height, seed),
+ lambda: tf.constant(0, dtype=tf.int32))
+
+ offset_width = tf.cond(
+ target_width > image_width,
+ lambda: _random_integer(0, target_width - image_width, seed),
+ lambda: tf.constant(0, dtype=tf.int32))
+
+ gen_func = lambda: (target_height, target_width, offset_height, offset_width)
+ params = _get_or_create_preprocess_rand_vars(
+ gen_func, preprocessor_cache.PreprocessorCache.PAD_IMAGE,
+ preprocess_vars_cache)
+ target_height, target_width, offset_height, offset_width = params
+
+ new_image = tf.image.pad_to_bounding_box(
+ image,
+ offset_height=offset_height,
+ offset_width=offset_width,
+ target_height=target_height,
+ target_width=target_width)
+
+ # Setting color of the padded pixels
+ image_ones = tf.ones_like(image)
+ image_ones_padded = tf.image.pad_to_bounding_box(
+ image_ones,
+ offset_height=offset_height,
+ offset_width=offset_width,
+ target_height=target_height,
+ target_width=target_width)
+ image_color_padded = (1.0 - image_ones_padded) * pad_color
+ new_image += image_color_padded
+
+ # setting boxes
+ new_window = tf.cast(
+ tf.stack([
+ -offset_height, -offset_width, target_height - offset_height,
+ target_width - offset_width
+ ]),
+ dtype=tf.float32)
+ new_window /= tf.cast(
+ tf.stack([image_height, image_width, image_height, image_width]),
+ dtype=tf.float32)
+ boxlist = box_list.BoxList(boxes)
+ new_boxlist = box_list_ops.change_coordinate_frame(boxlist, new_window)
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes]
+
+ if keypoints is not None:
+ new_keypoints = keypoint_ops.change_coordinate_frame(keypoints, new_window)
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_absolute_pad_image(image,
+ boxes,
+ max_height_padding,
+ max_width_padding,
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly pads the image by small absolute amounts.
+
+ As random_pad_image above, but the padding is of size [0, max_height_padding]
+ or [0, max_width_padding] instead of padding to a fixed size of
+ max_height_padding for all images.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ max_height_padding: a scalar tf.int32 tensor denoting the maximum amount of
+ height padding. The padding will be chosen uniformly at
+ random from [0, max_height_padding).
+ max_width_padding: a scalar tf.int32 tensor denoting the maximum amount of
+ width padding. The padding will be chosen uniformly at
+ random from [0, max_width_padding).
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the input
+ image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ """
+ min_image_size = tf.shape(image)[:2]
+ max_image_size = min_image_size + tf.cast(
+ [max_height_padding, max_width_padding], dtype=tf.int32)
+ return random_pad_image(image, boxes, min_image_size=min_image_size,
+ max_image_size=max_image_size, pad_color=pad_color,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+
+def random_crop_pad_image(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ min_object_covered=1.0,
+ aspect_ratio_range=(0.75, 1.33),
+ area_range=(0.1, 1.0),
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ random_coef=0.0,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ pad_color=None,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops and pads the image.
+
+ Given an input image and its bounding boxes, this op first randomly crops
+ the image and then randomly pads the image with background values. Parameters
+ min_padded_size_ratio and max_padded_size_ratio, determine the range of the
+ final output image size. Specifically, the final image size will have a size
+ in the range of min_padded_size_ratio * tf.shape(image) and
+ max_padded_size_ratio * tf.shape(image). Note that these ratios are with
+ respect to the size of the original image, so we can't capture the same
+ effect easily by independently applying RandomCropImage
+ followed by RandomPadImage.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 containing the label weights.
+ label_confidences: rank 1 float32 containing the label confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the randomly
+ cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ padded_image: padded image.
+ padded_boxes: boxes which is the same rank as input boxes. Boxes are in
+ normalized form.
+ cropped_labels: cropped labels.
+ if label_weights is not None also returns:
+ cropped_label_weights: cropped label weights.
+ if multiclass_scores is not None also returns:
+ cropped_multiclass_scores: cropped_multiclass_scores.
+
+ """
+ image_size = tf.shape(image)
+ image_height = image_size[0]
+ image_width = image_size[1]
+ result = random_crop_image(
+ image=image,
+ boxes=boxes,
+ labels=labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ cropped_image, cropped_boxes, cropped_labels = result[:3]
+
+ min_image_size = tf.cast(
+ tf.cast(tf.stack([image_height, image_width]), dtype=tf.float32) *
+ min_padded_size_ratio,
+ dtype=tf.int32)
+ max_image_size = tf.cast(
+ tf.cast(tf.stack([image_height, image_width]), dtype=tf.float32) *
+ max_padded_size_ratio,
+ dtype=tf.int32)
+
+ padded_image, padded_boxes = random_pad_image(
+ cropped_image,
+ cropped_boxes,
+ min_image_size=min_image_size,
+ max_image_size=max_image_size,
+ pad_color=pad_color,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ cropped_padded_output = (padded_image, padded_boxes, cropped_labels)
+
+ index = 3
+ if label_weights is not None:
+ cropped_label_weights = result[index]
+ cropped_padded_output += (cropped_label_weights,)
+ index += 1
+
+ if label_confidences is not None:
+ cropped_label_confidences = result[index]
+ cropped_padded_output += (cropped_label_confidences,)
+ index += 1
+
+ if multiclass_scores is not None:
+ cropped_multiclass_scores = result[index]
+ cropped_padded_output += (cropped_multiclass_scores,)
+
+ return cropped_padded_output
+
+
+def random_crop_to_aspect_ratio(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ aspect_ratio=1.0,
+ overlap_thresh=0.3,
+ clip_boxes=True,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly crops an image to the specified aspect ratio.
+
+ Randomly crops the a portion of the image such that the crop is of the
+ specified aspect ratio, and the crop is as large as possible. If the specified
+ aspect ratio is larger than the aspect ratio of the image, this op will
+ randomly remove rows from the top and bottom of the image. If the specified
+ aspect ratio is less than the aspect ratio of the image, this op will randomly
+ remove cols from the left and right of the image. If the specified aspect
+ ratio is the same as the aspect ratio of the image, this op will return the
+ image.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ aspect_ratio: the aspect ratio of cropped image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, masks, keypoints, or multiclass_scores is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+
+ Raises:
+ ValueError: If image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('RandomCropToAspectRatio', values=[image]):
+ image_shape = tf.shape(image)
+ orig_height = image_shape[0]
+ orig_width = image_shape[1]
+ orig_aspect_ratio = tf.cast(
+ orig_width, dtype=tf.float32) / tf.cast(
+ orig_height, dtype=tf.float32)
+ new_aspect_ratio = tf.constant(aspect_ratio, dtype=tf.float32)
+
+ def target_height_fn():
+ return tf.cast(
+ tf.round(tf.cast(orig_width, dtype=tf.float32) / new_aspect_ratio),
+ dtype=tf.int32)
+
+ target_height = tf.cond(orig_aspect_ratio >= new_aspect_ratio,
+ lambda: orig_height, target_height_fn)
+
+ def target_width_fn():
+ return tf.cast(
+ tf.round(tf.cast(orig_height, dtype=tf.float32) * new_aspect_ratio),
+ dtype=tf.int32)
+
+ target_width = tf.cond(orig_aspect_ratio <= new_aspect_ratio,
+ lambda: orig_width, target_width_fn)
+
+ # either offset_height = 0 and offset_width is randomly chosen from
+ # [0, offset_width - target_width), or else offset_width = 0 and
+ # offset_height is randomly chosen from [0, offset_height - target_height)
+ offset_height = _random_integer(0, orig_height - target_height + 1, seed)
+ offset_width = _random_integer(0, orig_width - target_width + 1, seed)
+
+ generator_func = lambda: (offset_height, offset_width)
+ offset_height, offset_width = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.CROP_TO_ASPECT_RATIO,
+ preprocess_vars_cache)
+
+ new_image = tf.image.crop_to_bounding_box(
+ image, offset_height, offset_width, target_height, target_width)
+
+ im_box = tf.stack([
+ tf.cast(offset_height, dtype=tf.float32) /
+ tf.cast(orig_height, dtype=tf.float32),
+ tf.cast(offset_width, dtype=tf.float32) /
+ tf.cast(orig_width, dtype=tf.float32),
+ tf.cast(offset_height + target_height, dtype=tf.float32) /
+ tf.cast(orig_height, dtype=tf.float32),
+ tf.cast(offset_width + target_width, dtype=tf.float32) /
+ tf.cast(orig_width, dtype=tf.float32)
+ ])
+
+ boxlist = box_list.BoxList(boxes)
+ boxlist.add_field('labels', labels)
+
+ boxlist.add_field('label_weights', label_weights)
+
+ if label_confidences is not None:
+ boxlist.add_field('label_confidences', label_confidences)
+
+ if multiclass_scores is not None:
+ boxlist.add_field('multiclass_scores', multiclass_scores)
+
+ im_boxlist = box_list.BoxList(tf.expand_dims(im_box, 0))
+
+ # remove boxes whose overlap with the image is less than overlap_thresh
+ overlapping_boxlist, keep_ids = box_list_ops.prune_non_overlapping_boxes(
+ boxlist, im_boxlist, overlap_thresh)
+
+ # change the coordinate of the remaining boxes
+ new_labels = overlapping_boxlist.get_field('labels')
+ new_boxlist = box_list_ops.change_coordinate_frame(overlapping_boxlist,
+ im_box)
+ if clip_boxes:
+ new_boxlist = box_list_ops.clip_to_window(
+ new_boxlist, tf.constant([0.0, 0.0, 1.0, 1.0], tf.float32))
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes, new_labels]
+
+ new_label_weights = overlapping_boxlist.get_field('label_weights')
+ result.append(new_label_weights)
+
+ if label_confidences is not None:
+ new_label_confidences = (
+ overlapping_boxlist.get_field('label_confidences'))
+ result.append(new_label_confidences)
+
+ if multiclass_scores is not None:
+ new_multiclass_scores = overlapping_boxlist.get_field('multiclass_scores')
+ result.append(new_multiclass_scores)
+
+ if masks is not None:
+ masks_inside_window = tf.gather(masks, keep_ids)
+ masks_box_begin = tf.stack([0, offset_height, offset_width])
+ masks_box_size = tf.stack([-1, target_height, target_width])
+ new_masks = tf.slice(masks_inside_window, masks_box_begin, masks_box_size)
+ result.append(new_masks)
+
+ if keypoints is not None:
+ keypoints_inside_window = tf.gather(keypoints, keep_ids)
+ new_keypoints = keypoint_ops.change_coordinate_frame(
+ keypoints_inside_window, im_box)
+ if clip_boxes:
+ new_keypoints = keypoint_ops.prune_outside_window(new_keypoints,
+ [0.0, 0.0, 1.0, 1.0])
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_pad_to_aspect_ratio(image,
+ boxes,
+ masks=None,
+ keypoints=None,
+ aspect_ratio=1.0,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly zero pads an image to the specified aspect ratio.
+
+ Pads the image so that the resulting image will have the specified aspect
+ ratio without scaling less than the min_padded_size_ratio or more than the
+ max_padded_size_ratio. If the min_padded_size_ratio or max_padded_size_ratio
+ is lower than what is possible to maintain the aspect ratio, then this method
+ will use the least padding to achieve the specified aspect ratio.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ aspect_ratio: aspect ratio of the final image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If masks, or keypoints is not None, the function also returns:
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+
+ Raises:
+ ValueError: If image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('RandomPadToAspectRatio', values=[image]):
+ image_shape = tf.shape(image)
+ image_height = tf.cast(image_shape[0], dtype=tf.float32)
+ image_width = tf.cast(image_shape[1], dtype=tf.float32)
+ image_aspect_ratio = image_width / image_height
+ new_aspect_ratio = tf.constant(aspect_ratio, dtype=tf.float32)
+ target_height = tf.cond(
+ image_aspect_ratio <= new_aspect_ratio,
+ lambda: image_height,
+ lambda: image_width / new_aspect_ratio)
+ target_width = tf.cond(
+ image_aspect_ratio >= new_aspect_ratio,
+ lambda: image_width,
+ lambda: image_height * new_aspect_ratio)
+
+ min_height = tf.maximum(
+ min_padded_size_ratio[0] * image_height, target_height)
+ min_width = tf.maximum(
+ min_padded_size_ratio[1] * image_width, target_width)
+ max_height = tf.maximum(
+ max_padded_size_ratio[0] * image_height, target_height)
+ max_width = tf.maximum(
+ max_padded_size_ratio[1] * image_width, target_width)
+
+ max_scale = tf.minimum(max_height / target_height, max_width / target_width)
+ min_scale = tf.minimum(
+ max_scale,
+ tf.maximum(min_height / target_height, min_width / target_width))
+
+ generator_func = functools.partial(tf.random_uniform, [],
+ min_scale, max_scale, seed=seed)
+ scale = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.PAD_TO_ASPECT_RATIO,
+ preprocess_vars_cache)
+
+ target_height = tf.round(scale * target_height)
+ target_width = tf.round(scale * target_width)
+
+ new_image = tf.image.pad_to_bounding_box(
+ image, 0, 0, tf.cast(target_height, dtype=tf.int32),
+ tf.cast(target_width, dtype=tf.int32))
+
+ im_box = tf.stack([
+ 0.0,
+ 0.0,
+ target_height / image_height,
+ target_width / image_width
+ ])
+ boxlist = box_list.BoxList(boxes)
+ new_boxlist = box_list_ops.change_coordinate_frame(boxlist, im_box)
+ new_boxes = new_boxlist.get()
+
+ result = [new_image, new_boxes]
+
+ if masks is not None:
+ new_masks = tf.expand_dims(masks, -1)
+ new_masks = tf.image.pad_to_bounding_box(
+ new_masks, 0, 0, tf.cast(target_height, dtype=tf.int32),
+ tf.cast(target_width, dtype=tf.int32))
+ new_masks = tf.squeeze(new_masks, [-1])
+ result.append(new_masks)
+
+ if keypoints is not None:
+ new_keypoints = keypoint_ops.change_coordinate_frame(keypoints, im_box)
+ result.append(new_keypoints)
+
+ return tuple(result)
+
+
+def random_black_patches(image,
+ max_black_patches=10,
+ probability=0.5,
+ size_to_image_ratio=0.1,
+ random_seed=None,
+ preprocess_vars_cache=None):
+ """Randomly adds some black patches to the image.
+
+ This op adds up to max_black_patches square black patches of a fixed size
+ to the image where size is specified via the size_to_image_ratio parameter.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ max_black_patches: number of times that the function tries to add a
+ black box to the image.
+ probability: at each try, what is the chance of adding a box.
+ size_to_image_ratio: Determines the ratio of the size of the black patches
+ to the size of the image.
+ box_size = size_to_image_ratio *
+ min(image_width, image_height)
+ random_seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image
+ """
+ def add_black_patch_to_image(image, idx):
+ """Function for adding one patch to the image.
+
+ Args:
+ image: image
+ idx: counter for number of patches that could have been added
+
+ Returns:
+ image with a randomly added black box
+ """
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ box_size = tf.cast(
+ tf.multiply(
+ tf.minimum(
+ tf.cast(image_height, dtype=tf.float32),
+ tf.cast(image_width, dtype=tf.float32)), size_to_image_ratio),
+ dtype=tf.int32)
+
+ generator_func = functools.partial(tf.random_uniform, [], minval=0.0,
+ maxval=(1.0 - size_to_image_ratio),
+ seed=random_seed)
+ normalized_y_min = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADD_BLACK_PATCH,
+ preprocess_vars_cache, key=str(idx) + 'y')
+ normalized_x_min = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.ADD_BLACK_PATCH,
+ preprocess_vars_cache, key=str(idx) + 'x')
+
+ y_min = tf.cast(
+ normalized_y_min * tf.cast(image_height, dtype=tf.float32),
+ dtype=tf.int32)
+ x_min = tf.cast(
+ normalized_x_min * tf.cast(image_width, dtype=tf.float32),
+ dtype=tf.int32)
+ black_box = tf.ones([box_size, box_size, 3], dtype=tf.float32)
+ mask = 1.0 - tf.image.pad_to_bounding_box(black_box, y_min, x_min,
+ image_height, image_width)
+ image = tf.multiply(image, mask)
+ return image
+
+ with tf.name_scope('RandomBlackPatchInImage', values=[image]):
+ for idx in range(max_black_patches):
+ generator_func = functools.partial(tf.random_uniform, [],
+ minval=0.0, maxval=1.0,
+ dtype=tf.float32, seed=random_seed)
+ random_prob = _get_or_create_preprocess_rand_vars(
+ generator_func,
+ preprocessor_cache.PreprocessorCache.BLACK_PATCHES,
+ preprocess_vars_cache, key=idx)
+ image = tf.cond(
+ tf.greater(random_prob, probability), lambda: image,
+ functools.partial(add_black_patch_to_image, image=image, idx=idx))
+ return image
+
+
+def random_jpeg_quality(image,
+ min_jpeg_quality=0,
+ max_jpeg_quality=100,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly encode the image to a random JPEG quality level.
+
+ Args:
+ image: rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0, 255].
+ min_jpeg_quality: An int for the lower bound for selecting a random jpeg
+ quality level.
+ max_jpeg_quality: An int for the upper bound for selecting a random jpeg
+ quality level.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the encoded image,
+ and if it is 1.0, we will always get the original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this function is called
+ multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ image: image which is the same shape as input image.
+ """
+ def _adjust_jpeg_quality():
+ """Encodes the image as jpeg with a random quality and then decodes."""
+ generator_func = functools.partial(
+ tf.random_uniform, [],
+ minval=min_jpeg_quality,
+ maxval=max_jpeg_quality,
+ dtype=tf.int32,
+ seed=seed)
+ quality = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.JPEG_QUALITY,
+ preprocess_vars_cache, key='quality')
+
+ # Need to convert to uint8 before calling adjust_jpeg_quality since it
+ # assumes that float features are in the range [0, 1], where herein the
+ # range is [0, 255].
+ image_uint8 = tf.cast(image, tf.uint8)
+ adjusted_image = tf.image.adjust_jpeg_quality(image_uint8, quality)
+ return tf.cast(adjusted_image, tf.float32)
+
+ with tf.name_scope('RandomJpegQuality', values=[image]):
+ generator_func = functools.partial(tf.random_uniform, [], seed=seed)
+ do_encoding_random = _get_or_create_preprocess_rand_vars(
+ generator_func, preprocessor_cache.PreprocessorCache.JPEG_QUALITY,
+ preprocess_vars_cache)
+ do_encoding_random = tf.greater_equal(do_encoding_random, random_coef)
+ image = tf.cond(do_encoding_random, _adjust_jpeg_quality,
+ lambda: tf.cast(image, tf.float32))
+
+ return image
+
+
+def random_downscale_to_target_pixels(image,
+ masks=None,
+ min_target_pixels=300000,
+ max_target_pixels=800000,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly downscales the image to a target number of pixels.
+
+ If the image contains less than the chosen target number of pixels, it will
+ not be downscaled.
+
+ Args:
+ image: Rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0, 255].
+ masks: (optional) Rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks are of
+ the same height, width as the input `image`.
+ min_target_pixels: Integer. An inclusive lower bound for for the target
+ number of pixels.
+ max_target_pixels: Integer. An exclusive upper bound for for the target
+ number of pixels.
+ random_coef: Float. Random coefficient that defines the chance of getting
+ the original image. If random_coef is 0, we will always apply downscaling,
+ and if it is 1.0, we will always get the original image.
+ seed: (optional) Integer. Random seed.
+ preprocess_vars_cache: (optional) PreprocessorCache object that records
+ previously performed augmentations. Updated in-place. If this function is
+ called multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ Tuple with elements:
+ image: Resized image which is the same rank as input image.
+ masks: If masks is not None, resized masks which are the same rank as
+ the input masks.
+
+ Raises:
+ ValueError: If min_target_pixels or max_target_pixels are not positive.
+ """
+ if min_target_pixels <= 0:
+ raise ValueError('Minimum target pixels must be positive')
+ if max_target_pixels <= 0:
+ raise ValueError('Maximum target pixels must be positive')
+
+ def _resize_image_to_target(target_height, target_width):
+ # pylint: disable=unbalanced-tuple-unpacking
+ new_image, _ = resize_image(image, None, target_height, target_width)
+ return (new_image,)
+
+ def _resize_image_and_masks_to_target(target_height, target_width):
+ # pylint: disable=unbalanced-tuple-unpacking
+ new_image, new_masks, _ = resize_image(image, masks, target_height,
+ target_width)
+ return new_image, new_masks
+
+ with tf.name_scope('RandomDownscaleToTargetPixels', values=[image]):
+ generator_fn = functools.partial(tf.random_uniform, [], seed=seed)
+ do_downscale_random = _get_or_create_preprocess_rand_vars(
+ generator_fn,
+ preprocessor_cache.PreprocessorCache.DOWNSCALE_TO_TARGET_PIXELS,
+ preprocess_vars_cache)
+ do_downscale_random = tf.greater_equal(do_downscale_random, random_coef)
+
+ generator_fn = functools.partial(
+ tf.random_uniform, [],
+ minval=min_target_pixels,
+ maxval=max_target_pixels,
+ dtype=tf.int32,
+ seed=seed)
+ target_pixels = _get_or_create_preprocess_rand_vars(
+ generator_fn,
+ preprocessor_cache.PreprocessorCache.DOWNSCALE_TO_TARGET_PIXELS,
+ preprocess_vars_cache,
+ key='target_pixels')
+
+ image_shape = tf.shape(image)
+ image_height = image_shape[0]
+ image_width = image_shape[1]
+ image_pixels = image_height * image_width
+ scale_factor = tf.sqrt(
+ tf.cast(target_pixels, dtype=tf.float32) /
+ tf.cast(image_pixels, dtype=tf.float32))
+ target_height = tf.cast(
+ scale_factor * tf.cast(image_height, dtype=tf.float32), dtype=tf.int32)
+ target_width = tf.cast(
+ scale_factor * tf.cast(image_width, dtype=tf.float32), dtype=tf.int32)
+ image_larger_than_target = tf.greater(image_pixels, target_pixels)
+
+ should_apply_resize = tf.logical_and(do_downscale_random,
+ image_larger_than_target)
+ if masks is not None:
+ resize_fn = functools.partial(_resize_image_and_masks_to_target,
+ target_height, target_width)
+ return tf.cond(should_apply_resize, resize_fn,
+ lambda: (tf.cast(image, dtype=tf.float32), masks))
+ else:
+ resize_fn = lambda: _resize_image_to_target(target_height, target_width)
+ return tf.cond(should_apply_resize, resize_fn,
+ lambda: (tf.cast(image, dtype=tf.float32),))
+
+
+def random_patch_gaussian(image,
+ min_patch_size=1,
+ max_patch_size=250,
+ min_gaussian_stddev=0.0,
+ max_gaussian_stddev=1.0,
+ random_coef=0.0,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Randomly applies gaussian noise to a random patch on the image.
+
+ The gaussian noise is applied to the image with values scaled to the range
+ [0.0, 1.0]. The result of applying gaussian noise to the scaled image is
+ clipped to be within the range [0.0, 1.0], equivalent to the range
+ [0.0, 255.0] after rescaling the image back.
+
+ See "Improving Robustness Without Sacrificing Accuracy with Patch Gaussian
+ Augmentation " by Lopes et al., 2019, for further details.
+ https://arxiv.org/abs/1906.02611
+
+ Args:
+ image: Rank 3 float32 tensor with shape [height, width, channels] and
+ values in the range [0.0, 255.0].
+ min_patch_size: Integer. An inclusive lower bound for the patch size.
+ max_patch_size: Integer. An exclusive upper bound for the patch size.
+ min_gaussian_stddev: Float. An inclusive lower bound for the standard
+ deviation of the gaussian noise.
+ max_gaussian_stddev: Float. An exclusive upper bound for the standard
+ deviation of the gaussian noise.
+ random_coef: Float. Random coefficient that defines the chance of getting
+ the original image. If random_coef is 0.0, we will always apply
+ downscaling, and if it is 1.0, we will always get the original image.
+ seed: (optional) Integer. Random seed.
+ preprocess_vars_cache: (optional) PreprocessorCache object that records
+ previously performed augmentations. Updated in-place. If this function is
+ called multiple times with the same non-null cache, it will perform
+ deterministically.
+
+ Returns:
+ Rank 3 float32 tensor with same shape as the input image and with gaussian
+ noise applied within a random patch.
+
+ Raises:
+ ValueError: If min_patch_size is < 1.
+ """
+ if min_patch_size < 1:
+ raise ValueError('Minimum patch size must be >= 1.')
+
+ get_or_create_rand_vars_fn = functools.partial(
+ _get_or_create_preprocess_rand_vars,
+ function_id=preprocessor_cache.PreprocessorCache.PATCH_GAUSSIAN,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ def _apply_patch_gaussian(image):
+ """Applies a patch gaussian with random size, location, and stddev."""
+ patch_size = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=min_patch_size,
+ maxval=max_patch_size,
+ dtype=tf.int32,
+ seed=seed),
+ key='patch_size')
+ gaussian_stddev = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=min_gaussian_stddev,
+ maxval=max_gaussian_stddev,
+ dtype=tf.float32,
+ seed=seed),
+ key='gaussian_stddev')
+
+ image_shape = tf.shape(image)
+ y = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=0,
+ maxval=image_shape[0],
+ dtype=tf.int32,
+ seed=seed),
+ key='y')
+ x = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random_uniform, [],
+ minval=0,
+ maxval=image_shape[1],
+ dtype=tf.int32,
+ seed=seed),
+ key='x')
+ gaussian = get_or_create_rand_vars_fn(
+ functools.partial(
+ tf.random.normal,
+ image_shape,
+ stddev=gaussian_stddev,
+ dtype=tf.float32,
+ seed=seed),
+ key='gaussian')
+
+ scaled_image = image / 255.0
+ image_plus_gaussian = tf.clip_by_value(scaled_image + gaussian, 0.0, 1.0)
+ patch_mask = patch_ops.get_patch_mask(y, x, patch_size, image_shape)
+ patch_mask = tf.expand_dims(patch_mask, -1)
+ patch_mask = tf.tile(patch_mask, [1, 1, image_shape[2]])
+ patched_image = tf.where(patch_mask, image_plus_gaussian, scaled_image)
+ return patched_image * 255.0
+
+ with tf.name_scope('RandomPatchGaussian', values=[image]):
+ image = tf.cast(image, tf.float32)
+ patch_gaussian_random = get_or_create_rand_vars_fn(
+ functools.partial(tf.random_uniform, [], seed=seed))
+ do_patch_gaussian = tf.greater_equal(patch_gaussian_random, random_coef)
+ image = tf.cond(do_patch_gaussian,
+ lambda: _apply_patch_gaussian(image),
+ lambda: image)
+ return image
+
+
+# TODO(barretzoph): Put in AutoAugment Paper link when paper is live.
+def autoaugment_image(image, boxes, policy_name='v0'):
+ """Apply an autoaugment policy to the image and boxes.
+
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 255].
+ boxes: rank 2 float32 tensor containing the bounding boxes with shape
+ [num_instances, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ policy_name: The name of the AutoAugment policy to use. The available
+ options are `v0`, `v1`, `v2`, `v3` and `test`. `v0` is the policy used for
+ all of the results in the paper and was found to achieve the best results
+ on the COCO dataset. `v1`, `v2` and `v3` are additional good policies
+ found on the COCO dataset that have slight variation in what operations
+ were used during the search procedure along with how many operations are
+ applied in parallel to a single image (2 vs 3).
+
+
+ Returns:
+ image: the augmented image.
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form. boxes will have been augmented along with image.
+ """
+ return autoaugment_utils.distort_image_with_autoaugment(
+ image, boxes, policy_name)
+
+
+def image_to_float(image):
+ """Used in Faster R-CNN. Casts image pixel values to float.
+
+ Args:
+ image: input image which might be in tf.uint8 or sth else format
+
+ Returns:
+ image: image in tf.float32 format.
+ """
+ with tf.name_scope('ImageToFloat', values=[image]):
+ image = tf.cast(image, dtype=tf.float32)
+ return image
+
+
+def random_resize_method(image, target_size, preprocess_vars_cache=None):
+ """Uses a random resize method to resize the image to target size.
+
+ Args:
+ image: a rank 3 tensor.
+ target_size: a list of [target_height, target_width]
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ resized image.
+ """
+
+ resized_image = _apply_with_random_selector(
+ image,
+ lambda x, method: tf.image.resize_images(x, target_size, method),
+ num_cases=4,
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.RESIZE_METHOD)
+
+ return resized_image
+
+
+def resize_to_range(image,
+ masks=None,
+ min_dimension=None,
+ max_dimension=None,
+ method=tf.image.ResizeMethod.BILINEAR,
+ align_corners=False,
+ pad_to_max_dimension=False,
+ per_channel_pad_value=(0, 0, 0)):
+ """Resizes an image so its dimensions are within the provided value.
+
+ The output size can be described by two cases:
+ 1. If the image can be rescaled so its minimum dimension is equal to the
+ provided value without the other dimension exceeding max_dimension,
+ then do so.
+ 2. Otherwise, resize so the largest dimension is equal to max_dimension.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks.
+ min_dimension: (optional) (scalar) desired size of the smaller image
+ dimension.
+ max_dimension: (optional) (scalar) maximum allowed size
+ of the larger image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+ align_corners: bool. If true, exactly align all 4 corners of the input
+ and output. Defaults to False.
+ pad_to_max_dimension: Whether to resize the image and pad it with zeros
+ so the resulting image is of the spatial size
+ [max_dimension, max_dimension]. If masks are included they are padded
+ similarly.
+ per_channel_pad_value: A tuple of per-channel scalar value to use for
+ padding. By default pads zeros.
+
+ Returns:
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A 3D tensor of shape [new_height, new_width, channels],
+ where the image has been resized (with bilinear interpolation) so that
+ min(new_height, new_width) == min_dimension or
+ max(new_height, new_width) == max_dimension.
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width].
+ resized_image_shape: A 1D tensor of shape [3] containing shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ def _resize_landscape_image(image):
+ # resize a landscape image
+ return tf.image.resize_images(
+ image, tf.stack([min_dimension, max_dimension]), method=method,
+ align_corners=align_corners, preserve_aspect_ratio=True)
+
+ def _resize_portrait_image(image):
+ # resize a portrait image
+ return tf.image.resize_images(
+ image, tf.stack([max_dimension, min_dimension]), method=method,
+ align_corners=align_corners, preserve_aspect_ratio=True)
+
+ with tf.name_scope('ResizeToRange', values=[image, min_dimension]):
+ if image.get_shape().is_fully_defined():
+ if image.get_shape()[0] < image.get_shape()[1]:
+ new_image = _resize_landscape_image(image)
+ else:
+ new_image = _resize_portrait_image(image)
+ new_size = tf.constant(new_image.get_shape().as_list())
+ else:
+ new_image = tf.cond(
+ tf.less(tf.shape(image)[0], tf.shape(image)[1]),
+ lambda: _resize_landscape_image(image),
+ lambda: _resize_portrait_image(image))
+ new_size = tf.shape(new_image)
+
+ if pad_to_max_dimension:
+ channels = tf.unstack(new_image, axis=2)
+ if len(channels) != len(per_channel_pad_value):
+ raise ValueError('Number of channels must be equal to the length of '
+ 'per-channel pad value.')
+ new_image = tf.stack(
+ [
+ tf.pad(
+ channels[i], [[0, max_dimension - new_size[0]],
+ [0, max_dimension - new_size[1]]],
+ constant_values=per_channel_pad_value[i])
+ for i in range(len(channels))
+ ],
+ axis=2)
+ new_image.set_shape([max_dimension, max_dimension, 3])
+
+ result = [new_image]
+ if masks is not None:
+ new_masks = tf.expand_dims(masks, 3)
+ new_masks = tf.image.resize_images(
+ new_masks,
+ new_size[:-1],
+ method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
+ align_corners=align_corners)
+ if pad_to_max_dimension:
+ new_masks = tf.image.pad_to_bounding_box(
+ new_masks, 0, 0, max_dimension, max_dimension)
+ new_masks = tf.squeeze(new_masks, 3)
+ result.append(new_masks)
+
+ result.append(new_size)
+ return result
+
+
+def _get_image_info(image):
+ """Returns the height, width and number of channels in the image."""
+ image_height = tf.shape(image)[0]
+ image_width = tf.shape(image)[1]
+ num_channels = tf.shape(image)[2]
+ return (image_height, image_width, num_channels)
+
+
+# TODO(alirezafathi): Make sure the static shapes are preserved.
+def resize_to_min_dimension(image, masks=None, min_dimension=600,
+ method=tf.image.ResizeMethod.BILINEAR):
+ """Resizes image and masks given the min size maintaining the aspect ratio.
+
+ If one of the image dimensions is smaller than min_dimension, it will scale
+ the image such that its smallest dimension is equal to min_dimension.
+ Otherwise, will keep the image size as is.
+
+ Args:
+ image: a tensor of size [height, width, channels].
+ masks: (optional) a tensors of size [num_instances, height, width].
+ min_dimension: minimum image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+
+ Returns:
+ An array containing resized_image, resized_masks, and resized_image_shape.
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('ResizeGivenMinDimension', values=[image, min_dimension]):
+ (image_height, image_width, num_channels) = _get_image_info(image)
+ min_image_dimension = tf.minimum(image_height, image_width)
+ min_target_dimension = tf.maximum(min_image_dimension, min_dimension)
+ target_ratio = tf.cast(min_target_dimension, dtype=tf.float32) / tf.cast(
+ min_image_dimension, dtype=tf.float32)
+ target_height = tf.cast(
+ tf.cast(image_height, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ target_width = tf.cast(
+ tf.cast(image_width, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ image = tf.image.resize_images(
+ tf.expand_dims(image, axis=0), size=[target_height, target_width],
+ method=method,
+ align_corners=True)
+ result = [tf.squeeze(image, axis=0)]
+
+ if masks is not None:
+ masks = tf.image.resize_nearest_neighbor(
+ tf.expand_dims(masks, axis=3),
+ size=[target_height, target_width],
+ align_corners=True)
+ result.append(tf.squeeze(masks, axis=3))
+
+ result.append(tf.stack([target_height, target_width, num_channels]))
+ return result
+
+
+def resize_to_max_dimension(image, masks=None, max_dimension=600,
+ method=tf.image.ResizeMethod.BILINEAR):
+ """Resizes image and masks given the max size maintaining the aspect ratio.
+
+ If one of the image dimensions is greater than max_dimension, it will scale
+ the image such that its largest dimension is equal to max_dimension.
+ Otherwise, will keep the image size as is.
+
+ Args:
+ image: a tensor of size [height, width, channels].
+ masks: (optional) a tensors of size [num_instances, height, width].
+ max_dimension: maximum image dimension.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+
+ Returns:
+ An array containing resized_image, resized_masks, and resized_image_shape.
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+
+ Raises:
+ ValueError: if the image is not a 3D tensor.
+ """
+ if len(image.get_shape()) != 3:
+ raise ValueError('Image should be 3D tensor')
+
+ with tf.name_scope('ResizeGivenMaxDimension', values=[image, max_dimension]):
+ (image_height, image_width, num_channels) = _get_image_info(image)
+ max_image_dimension = tf.maximum(image_height, image_width)
+ max_target_dimension = tf.minimum(max_image_dimension, max_dimension)
+ target_ratio = tf.cast(max_target_dimension, dtype=tf.float32) / tf.cast(
+ max_image_dimension, dtype=tf.float32)
+ target_height = tf.cast(
+ tf.cast(image_height, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ target_width = tf.cast(
+ tf.cast(image_width, dtype=tf.float32) * target_ratio, dtype=tf.int32)
+ image = tf.image.resize_images(
+ tf.expand_dims(image, axis=0), size=[target_height, target_width],
+ method=method,
+ align_corners=True)
+ result = [tf.squeeze(image, axis=0)]
+
+ if masks is not None:
+ masks = tf.image.resize_nearest_neighbor(
+ tf.expand_dims(masks, axis=3),
+ size=[target_height, target_width],
+ align_corners=True)
+ result.append(tf.squeeze(masks, axis=3))
+
+ result.append(tf.stack([target_height, target_width, num_channels]))
+ return result
+
+
+def scale_boxes_to_pixel_coordinates(image, boxes, keypoints=None):
+ """Scales boxes from normalized to pixel coordinates.
+
+ Args:
+ image: A 3D float32 tensor of shape [height, width, channels].
+ boxes: A 2D float32 tensor of shape [num_boxes, 4] containing the bounding
+ boxes in normalized coordinates. Each row is of the form
+ [ymin, xmin, ymax, xmax].
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x normalized
+ coordinates.
+
+ Returns:
+ image: unchanged input image.
+ scaled_boxes: a 2D float32 tensor of shape [num_boxes, 4] containing the
+ bounding boxes in pixel coordinates.
+ scaled_keypoints: a 3D float32 tensor with shape
+ [num_instances, num_keypoints, 2] containing the keypoints in pixel
+ coordinates.
+ """
+ boxlist = box_list.BoxList(boxes)
+ image_height = tf.shape(image)[0]
+ image_width = tf.shape(image)[1]
+ scaled_boxes = box_list_ops.scale(boxlist, image_height, image_width).get()
+ result = [image, scaled_boxes]
+ if keypoints is not None:
+ scaled_keypoints = keypoint_ops.scale(keypoints, image_height, image_width)
+ result.append(scaled_keypoints)
+ return tuple(result)
+
+
+# TODO(alirezafathi): Investigate if instead the function should return None if
+# masks is None.
+# pylint: disable=g-doc-return-or-yield
+def resize_image(image,
+ masks=None,
+ new_height=600,
+ new_width=1024,
+ method=tf.image.ResizeMethod.BILINEAR,
+ align_corners=False):
+ """Resizes images to the given height and width.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks.
+ new_height: (optional) (scalar) desired height of the image.
+ new_width: (optional) (scalar) desired width of the image.
+ method: (optional) interpolation method used in resizing. Defaults to
+ BILINEAR.
+ align_corners: bool. If true, exactly align all 4 corners of the input
+ and output. Defaults to False.
+
+ Returns:
+ Note that the position of the resized_image_shape changes based on whether
+ masks are present.
+ resized_image: A tensor of size [new_height, new_width, channels].
+ resized_masks: If masks is not None, also outputs masks. A 3D tensor of
+ shape [num_instances, new_height, new_width]
+ resized_image_shape: A 1D tensor of shape [3] containing the shape of the
+ resized image.
+ """
+ with tf.name_scope(
+ 'ResizeImage',
+ values=[image, new_height, new_width, method, align_corners]):
+ new_image = tf.image.resize_images(
+ image, tf.stack([new_height, new_width]),
+ method=method,
+ align_corners=align_corners)
+ image_shape = shape_utils.combined_static_and_dynamic_shape(image)
+ result = [new_image]
+ if masks is not None:
+ num_instances = tf.shape(masks)[0]
+ new_size = tf.stack([new_height, new_width])
+ def resize_masks_branch():
+ new_masks = tf.expand_dims(masks, 3)
+ new_masks = tf.image.resize_nearest_neighbor(
+ new_masks, new_size, align_corners=align_corners)
+ new_masks = tf.squeeze(new_masks, axis=3)
+ return new_masks
+
+ def reshape_masks_branch():
+ # The shape function will be computed for both branches of the
+ # condition, regardless of which branch is actually taken. Make sure
+ # that we don't trigger an assertion in the shape function when trying
+ # to reshape a non empty tensor into an empty one.
+ new_masks = tf.reshape(masks, [-1, new_size[0], new_size[1]])
+ return new_masks
+
+ masks = tf.cond(num_instances > 0, resize_masks_branch,
+ reshape_masks_branch)
+ result.append(masks)
+
+ result.append(tf.stack([new_height, new_width, image_shape[2]]))
+ return result
+
+
+def subtract_channel_mean(image, means=None):
+ """Normalizes an image by subtracting a mean from each channel.
+
+ Args:
+ image: A 3D tensor of shape [height, width, channels]
+ means: float list containing a mean for each channel
+ Returns:
+ normalized_images: a tensor of shape [height, width, channels]
+ Raises:
+ ValueError: if images is not a 4D tensor or if the number of means is not
+ equal to the number of channels.
+ """
+ with tf.name_scope('SubtractChannelMean', values=[image, means]):
+ if len(image.get_shape()) != 3:
+ raise ValueError('Input must be of size [height, width, channels]')
+ if len(means) != image.get_shape()[-1]:
+ raise ValueError('len(means) must match the number of channels')
+ return image - [[means]]
+
+
+def one_hot_encoding(labels, num_classes=None):
+ """One-hot encodes the multiclass labels.
+
+ Example usage:
+ labels = tf.constant([1, 4], dtype=tf.int32)
+ one_hot = OneHotEncoding(labels, num_classes=5)
+ one_hot.eval() # evaluates to [0, 1, 0, 0, 1]
+
+ Args:
+ labels: A tensor of shape [None] corresponding to the labels.
+ num_classes: Number of classes in the dataset.
+ Returns:
+ onehot_labels: a tensor of shape [num_classes] corresponding to the one hot
+ encoding of the labels.
+ Raises:
+ ValueError: if num_classes is not specified.
+ """
+ with tf.name_scope('OneHotEncoding', values=[labels]):
+ if num_classes is None:
+ raise ValueError('num_classes must be specified')
+
+ labels = tf.one_hot(labels, num_classes, 1, 0)
+ return tf.reduce_max(labels, 0)
+
+
+def rgb_to_gray(image):
+ """Converts a 3 channel RGB image to a 1 channel grayscale image.
+
+ Args:
+ image: Rank 3 float32 tensor containing 1 image -> [height, width, 3]
+ with pixel values varying between [0, 1].
+
+ Returns:
+ image: A single channel grayscale image -> [image, height, 1].
+ """
+ return _rgb_to_grayscale(image)
+
+
+def random_self_concat_image(
+ image, boxes, labels, label_weights, label_confidences=None,
+ multiclass_scores=None, concat_vertical_probability=0.1,
+ concat_horizontal_probability=0.1, seed=None,
+ preprocess_vars_cache=None):
+ """Randomly concatenates the image with itself.
+
+ This function randomly concatenates the image with itself; the random
+ variables for vertical and horizontal concatenation are independent.
+ Afterwards, we adjust the old bounding boxes, and add new bounding boxes
+ for the new objects.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 containing the label weights.
+ label_confidences: (optional) rank 1 float32 containing the label
+ confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for
+ each box for each class.
+ concat_vertical_probability: (optional) a tf.float32 scalar denoting the
+ probability of a vertical concatenation.
+ concat_horizontal_probability: (optional) a tf.float32 scalar denoting the
+ probability of a horizontal concatenation.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ if label_confidences is not None also returns:
+ maybe_concat_label_confidences: cropped label weights.
+ if multiclass_scores is not None also returns:
+ maybe_concat_multiclass_scores: cropped_multiclass_scores.
+ """
+
+ concat_vertical = (tf.random_uniform([], seed=seed) <
+ concat_vertical_probability)
+ # Note the seed + 1 so we get some semblance of independence even with
+ # fixed seeds.
+ concat_horizontal = (tf.random_uniform([], seed=seed + 1 if seed else None)
+ < concat_horizontal_probability)
+
+ gen_func = lambda: (concat_vertical, concat_horizontal)
+ params = _get_or_create_preprocess_rand_vars(
+ gen_func, preprocessor_cache.PreprocessorCache.SELF_CONCAT_IMAGE,
+ preprocess_vars_cache)
+ concat_vertical, concat_horizontal = params
+
+ def _concat_image(image, boxes, labels, label_weights, axis):
+ """Concats the image to itself on `axis`."""
+ output_images = tf.concat([image, image], axis=axis)
+
+ if axis == 0:
+ # Concat vertically, so need to reduce the y coordinates.
+ old_scaling = tf.constant([0.5, 1.0, 0.5, 1.0])
+ new_translation = tf.constant([0.5, 0.0, 0.5, 0.0])
+ elif axis == 1:
+ old_scaling = tf.constant([1.0, 0.5, 1.0, 0.5])
+ new_translation = tf.constant([0.0, 0.5, 0.0, 0.5])
+
+ old_boxes = old_scaling * boxes
+ new_boxes = old_boxes + new_translation
+ all_boxes = tf.concat([old_boxes, new_boxes], axis=0)
+
+ return [output_images, all_boxes, tf.tile(labels, [2]), tf.tile(
+ label_weights, [2])]
+
+ image, boxes, labels, label_weights = tf.cond(
+ concat_vertical,
+ lambda: _concat_image(image, boxes, labels, label_weights, axis=0),
+ lambda: [image, boxes, labels, label_weights],
+ strict=True)
+
+ outputs = tf.cond(
+ concat_horizontal,
+ lambda: _concat_image(image, boxes, labels, label_weights, axis=1),
+ lambda: [image, boxes, labels, label_weights],
+ strict=True)
+
+ if label_confidences is not None:
+ label_confidences = tf.cond(concat_vertical,
+ lambda: tf.tile(label_confidences, [2]),
+ lambda: label_confidences)
+ outputs.append(tf.cond(concat_horizontal,
+ lambda: tf.tile(label_confidences, [2]),
+ lambda: label_confidences))
+
+ if multiclass_scores is not None:
+ multiclass_scores = tf.cond(concat_vertical,
+ lambda: tf.tile(multiclass_scores, [2, 1]),
+ lambda: multiclass_scores)
+ outputs.append(tf.cond(concat_horizontal,
+ lambda: tf.tile(multiclass_scores, [2, 1]),
+ lambda: multiclass_scores))
+
+ return outputs
+
+
+def ssd_random_crop(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio_range=((0.5, 2.0),) * 7,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: rank 1 float32 tensor containing the weights.
+ label_confidences: rank 1 float32 tensor containing the confidences.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If label_weights, multiclass_scores, masks, or keypoints is not None, the
+ function also returns:
+ label_weights: rank 1 float32 tensor with shape [num_instances].
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+
+ def random_crop_selector(selected_result, index):
+ """Applies random_crop_image to selected result.
+
+ Args:
+ selected_result: A tuple containing image, boxes, labels, keypoints (if
+ not None), and masks (if not None).
+ index: The index that was randomly selected.
+
+ Returns: A tuple containing image, boxes, labels, keypoints (if not None),
+ and masks (if not None).
+ """
+
+ i = 3
+ image, boxes, labels = selected_result[:i]
+ selected_label_weights = None
+ selected_label_confidences = None
+ selected_multiclass_scores = None
+ selected_masks = None
+ selected_keypoints = None
+ if label_weights is not None:
+ selected_label_weights = selected_result[i]
+ i += 1
+ if label_confidences is not None:
+ selected_label_confidences = selected_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ selected_multiclass_scores = selected_result[i]
+ i += 1
+ if masks is not None:
+ selected_masks = selected_result[i]
+ i += 1
+ if keypoints is not None:
+ selected_keypoints = selected_result[i]
+
+ return random_crop_image(
+ image=image,
+ boxes=boxes,
+ labels=labels,
+ label_weights=selected_label_weights,
+ label_confidences=selected_label_confidences,
+ multiclass_scores=selected_multiclass_scores,
+ masks=selected_masks,
+ keypoints=selected_keypoints,
+ min_object_covered=min_object_covered[index],
+ aspect_ratio_range=aspect_ratio_range[index],
+ area_range=area_range[index],
+ overlap_thresh=overlap_thresh[index],
+ clip_boxes=clip_boxes[index],
+ random_coef=random_coef[index],
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ result = _apply_with_random_selector_tuples(
+ tuple(
+ t for t in (image, boxes, labels, label_weights, label_confidences,
+ multiclass_scores, masks, keypoints) if t is not None),
+ random_crop_selector,
+ num_cases=len(min_object_covered),
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.SSD_CROP_SELECTOR_ID)
+ return result
+
+
+def ssd_random_crop_pad(image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ min_object_covered=(0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio_range=((0.5, 2.0),) * 6,
+ area_range=((0.1, 1.0),) * 6,
+ overlap_thresh=(0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 6,
+ random_coef=(0.15,) * 6,
+ min_padded_size_ratio=((1.0, 1.0),) * 6,
+ max_padded_size_ratio=((2.0, 2.0),) * 6,
+ pad_color=(None,) * 6,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ Args:
+ image: rank 3 float32 tensor containing 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: float32 tensor of shape [num_instances] representing the
+ confidences for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ pad_color: padding color. A rank 1 tensor of [3] with dtype=tf.float32.
+ if set as None, it will be set to average color of the randomly
+ cropped image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: Image shape will be [new_height, new_width, channels].
+ boxes: boxes which is the same rank as input boxes. Boxes are in normalized
+ form.
+ new_labels: new labels.
+ new_label_weights: new label weights.
+ """
+
+ def random_crop_pad_selector(image_boxes_labels, index):
+ """Random crop preprocessing helper."""
+ i = 3
+ image, boxes, labels = image_boxes_labels[:i]
+ selected_label_weights = None
+ selected_label_confidences = None
+ selected_multiclass_scores = None
+ if label_weights is not None:
+ selected_label_weights = image_boxes_labels[i]
+ i += 1
+ if label_confidences is not None:
+ selected_label_confidences = image_boxes_labels[i]
+ i += 1
+ if multiclass_scores is not None:
+ selected_multiclass_scores = image_boxes_labels[i]
+
+ return random_crop_pad_image(
+ image,
+ boxes,
+ labels,
+ label_weights=selected_label_weights,
+ label_confidences=selected_label_confidences,
+ multiclass_scores=selected_multiclass_scores,
+ min_object_covered=min_object_covered[index],
+ aspect_ratio_range=aspect_ratio_range[index],
+ area_range=area_range[index],
+ overlap_thresh=overlap_thresh[index],
+ clip_boxes=clip_boxes[index],
+ random_coef=random_coef[index],
+ min_padded_size_ratio=min_padded_size_ratio[index],
+ max_padded_size_ratio=max_padded_size_ratio[index],
+ pad_color=pad_color[index],
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ return _apply_with_random_selector_tuples(
+ tuple(t for t in (image, boxes, labels, label_weights, label_confidences,
+ multiclass_scores) if t is not None),
+ random_crop_pad_selector,
+ num_cases=len(min_object_covered),
+ preprocess_vars_cache=preprocess_vars_cache,
+ key=preprocessor_cache.PreprocessorCache.SSD_CROP_PAD_SELECTOR_ID)
+
+
+def ssd_random_crop_fixed_aspect_ratio(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio=1.0,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ The only difference is that the aspect ratio of the crops are fixed.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidences for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio: aspect ratio of the cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If multiclass_scores, masks, or keypoints is not None, the function also
+ returns:
+
+ multiclass_scores: rank 2 float32 tensor with shape
+ [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ aspect_ratio_range = ((aspect_ratio, aspect_ratio),) * len(area_range)
+
+ crop_result = ssd_random_crop(
+ image,
+ boxes,
+ labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+ i = 3
+ new_image, new_boxes, new_labels = crop_result[:i]
+ new_label_weights = None
+ new_label_confidences = None
+ new_multiclass_scores = None
+ new_masks = None
+ new_keypoints = None
+ if label_weights is not None:
+ new_label_weights = crop_result[i]
+ i += 1
+ if label_confidences is not None:
+ new_label_confidences = crop_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ new_multiclass_scores = crop_result[i]
+ i += 1
+ if masks is not None:
+ new_masks = crop_result[i]
+ i += 1
+ if keypoints is not None:
+ new_keypoints = crop_result[i]
+
+ result = random_crop_to_aspect_ratio(
+ new_image,
+ new_boxes,
+ new_labels,
+ label_weights=new_label_weights,
+ label_confidences=new_label_confidences,
+ multiclass_scores=new_multiclass_scores,
+ masks=new_masks,
+ keypoints=new_keypoints,
+ aspect_ratio=aspect_ratio,
+ clip_boxes=clip_boxes,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ return result
+
+
+def ssd_random_crop_pad_fixed_aspect_ratio(
+ image,
+ boxes,
+ labels,
+ label_weights,
+ label_confidences=None,
+ multiclass_scores=None,
+ masks=None,
+ keypoints=None,
+ min_object_covered=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ aspect_ratio=1.0,
+ aspect_ratio_range=((0.5, 2.0),) * 7,
+ area_range=((0.1, 1.0),) * 7,
+ overlap_thresh=(0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0),
+ clip_boxes=(True,) * 7,
+ random_coef=(0.15,) * 7,
+ min_padded_size_ratio=(1.0, 1.0),
+ max_padded_size_ratio=(2.0, 2.0),
+ seed=None,
+ preprocess_vars_cache=None):
+ """Random crop and pad preprocessing with default parameters as in SSD paper.
+
+ Liu et al., SSD: Single shot multibox detector.
+ For further information on random crop preprocessing refer to RandomCrop
+ function above.
+
+ The only difference is that after the initial crop, images are zero-padded
+ to a fixed aspect ratio instead of being resized to that aspect ratio.
+
+ Args:
+ image: rank 3 float32 tensor contains 1 image -> [height, width, channels]
+ with pixel values varying between [0, 1].
+ boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning their coordinates vary
+ between [0, 1].
+ Each row is in the form of [ymin, xmin, ymax, xmax].
+ labels: rank 1 int32 tensor containing the object classes.
+ label_weights: float32 tensor of shape [num_instances] representing the
+ weight for each box.
+ label_confidences: (optional) float32 tensor of shape [num_instances]
+ representing the confidence for each box.
+ multiclass_scores: (optional) float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ masks: (optional) rank 3 float32 tensor with shape
+ [num_instances, height, width] containing instance masks. The masks
+ are of the same height, width as the input `image`.
+ keypoints: (optional) rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]. The keypoints are in y-x
+ normalized coordinates.
+ min_object_covered: the cropped image must cover at least this fraction of
+ at least one of the input bounding boxes.
+ aspect_ratio: the final aspect ratio to pad to.
+ aspect_ratio_range: allowed range for aspect ratio of cropped image.
+ area_range: allowed range for area ratio between cropped image and the
+ original image.
+ overlap_thresh: minimum overlap thresh with new cropped
+ image to keep the box.
+ clip_boxes: whether to clip the boxes to the cropped image.
+ random_coef: a random coefficient that defines the chance of getting the
+ original image. If random_coef is 0, we will always get the
+ cropped image, and if it is 1.0, we will always get the
+ original image.
+ min_padded_size_ratio: min ratio of padded image height and width to the
+ input image's height and width.
+ max_padded_size_ratio: max ratio of padded image height and width to the
+ input image's height and width.
+ seed: random seed.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ image: image which is the same rank as input image.
+ boxes: boxes which is the same rank as input boxes.
+ Boxes are in normalized form.
+ labels: new labels.
+
+ If multiclass_scores, masks, or keypoints is not None, the function also
+ returns:
+
+ multiclass_scores: rank 2 with shape [num_instances, num_classes]
+ masks: rank 3 float32 tensor with shape [num_instances, height, width]
+ containing instance masks.
+ keypoints: rank 3 float32 tensor with shape
+ [num_instances, num_keypoints, 2]
+ """
+ crop_result = ssd_random_crop(
+ image,
+ boxes,
+ labels,
+ label_weights=label_weights,
+ label_confidences=label_confidences,
+ multiclass_scores=multiclass_scores,
+ masks=masks,
+ keypoints=keypoints,
+ min_object_covered=min_object_covered,
+ aspect_ratio_range=aspect_ratio_range,
+ area_range=area_range,
+ overlap_thresh=overlap_thresh,
+ clip_boxes=clip_boxes,
+ random_coef=random_coef,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+ i = 3
+ new_image, new_boxes, new_labels = crop_result[:i]
+ new_label_weights = None
+ new_label_confidences = None
+ new_multiclass_scores = None
+ new_masks = None
+ new_keypoints = None
+ if label_weights is not None:
+ new_label_weights = crop_result[i]
+ i += 1
+ if label_confidences is not None:
+ new_label_confidences = crop_result[i]
+ i += 1
+ if multiclass_scores is not None:
+ new_multiclass_scores = crop_result[i]
+ i += 1
+ if masks is not None:
+ new_masks = crop_result[i]
+ i += 1
+ if keypoints is not None:
+ new_keypoints = crop_result[i]
+
+ result = random_pad_to_aspect_ratio(
+ new_image,
+ new_boxes,
+ masks=new_masks,
+ keypoints=new_keypoints,
+ aspect_ratio=aspect_ratio,
+ min_padded_size_ratio=min_padded_size_ratio,
+ max_padded_size_ratio=max_padded_size_ratio,
+ seed=seed,
+ preprocess_vars_cache=preprocess_vars_cache)
+
+ result = list(result)
+ i = 3
+ result.insert(2, new_labels)
+ if new_label_weights is not None:
+ result.insert(i, new_label_weights)
+ i += 1
+ if new_label_confidences is not None:
+ result.insert(i, new_label_confidences)
+ i += 1
+ if multiclass_scores is not None:
+ result.insert(i, new_multiclass_scores)
+ result = tuple(result)
+
+ return result
+
+
+def convert_class_logits_to_softmax(multiclass_scores, temperature=1.0):
+ """Converts multiclass logits to softmax scores after applying temperature.
+
+ Args:
+ multiclass_scores: float32 tensor of shape
+ [num_instances, num_classes] representing the score for each box for each
+ class.
+ temperature: Scale factor to use prior to applying softmax. Larger
+ temperatures give more uniform distruibutions after softmax.
+
+ Returns:
+ multiclass_scores: float32 tensor of shape
+ [num_instances, num_classes] with scaling and softmax applied.
+ """
+
+ # Multiclass scores must be stored as logits. Apply temp and softmax.
+ multiclass_scores_scaled = tf.divide(
+ multiclass_scores, temperature, name='scale_logits')
+ multiclass_scores = tf.nn.softmax(multiclass_scores_scaled, name='softmax')
+
+ return multiclass_scores
+
+
+def get_default_func_arg_map(include_label_weights=True,
+ include_label_confidences=False,
+ include_multiclass_scores=False,
+ include_instance_masks=False,
+ include_keypoints=False):
+ """Returns the default mapping from a preprocessor function to its args.
+
+ Args:
+ include_label_weights: If True, preprocessing functions will modify the
+ label weights, too.
+ include_label_confidences: If True, preprocessing functions will modify the
+ label confidences, too.
+ include_multiclass_scores: If True, preprocessing functions will modify the
+ multiclass scores, too.
+ include_instance_masks: If True, preprocessing functions will modify the
+ instance masks, too.
+ include_keypoints: If True, preprocessing functions will modify the
+ keypoints, too.
+
+ Returns:
+ A map from preprocessing functions to the arguments they receive.
+ """
+ groundtruth_label_weights = None
+ if include_label_weights:
+ groundtruth_label_weights = (
+ fields.InputDataFields.groundtruth_weights)
+
+ groundtruth_label_confidences = None
+ if include_label_confidences:
+ groundtruth_label_confidences = (
+ fields.InputDataFields.groundtruth_confidences)
+
+ multiclass_scores = None
+ if include_multiclass_scores:
+ multiclass_scores = (fields.InputDataFields.multiclass_scores)
+
+ groundtruth_instance_masks = None
+ if include_instance_masks:
+ groundtruth_instance_masks = (
+ fields.InputDataFields.groundtruth_instance_masks)
+
+ groundtruth_keypoints = None
+ if include_keypoints:
+ groundtruth_keypoints = fields.InputDataFields.groundtruth_keypoints
+
+ prep_func_arg_map = {
+ normalize_image: (fields.InputDataFields.image,),
+ random_horizontal_flip: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_vertical_flip: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_rotation90: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_pixel_value_scale: (fields.InputDataFields.image,),
+ random_image_scale: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ random_rgb_to_gray: (fields.InputDataFields.image,),
+ random_adjust_brightness: (fields.InputDataFields.image,),
+ random_adjust_contrast: (fields.InputDataFields.image,),
+ random_adjust_hue: (fields.InputDataFields.image,),
+ random_adjust_saturation: (fields.InputDataFields.image,),
+ random_distort_color: (fields.InputDataFields.image,),
+ random_jitter_boxes: (fields.InputDataFields.groundtruth_boxes,),
+ random_crop_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ random_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_keypoints),
+ random_absolute_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes),
+ random_crop_pad_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ random_crop_to_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_pad_to_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ random_black_patches: (fields.InputDataFields.image,),
+ random_jpeg_quality: (fields.InputDataFields.image,),
+ random_downscale_to_target_pixels: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ random_patch_gaussian: (fields.InputDataFields.image,),
+ autoaugment_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,),
+ retain_boxes_above_threshold: (
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ drop_label_probabilistically: (
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ remap_labels: (fields.InputDataFields.groundtruth_classes,),
+ image_to_float: (fields.InputDataFields.image,),
+ random_resize_method: (fields.InputDataFields.image,),
+ resize_to_range: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ resize_to_min_dimension: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ scale_boxes_to_pixel_coordinates: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ groundtruth_keypoints,
+ ),
+ resize_image: (
+ fields.InputDataFields.image,
+ groundtruth_instance_masks,
+ ),
+ subtract_channel_mean: (fields.InputDataFields.image,),
+ one_hot_encoding: (fields.InputDataFields.groundtruth_image_classes,),
+ rgb_to_gray: (fields.InputDataFields.image,),
+ random_self_concat_image: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ ssd_random_crop: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ ssd_random_crop_pad: (fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores),
+ ssd_random_crop_fixed_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints),
+ ssd_random_crop_pad_fixed_aspect_ratio: (
+ fields.InputDataFields.image,
+ fields.InputDataFields.groundtruth_boxes,
+ fields.InputDataFields.groundtruth_classes,
+ groundtruth_label_weights,
+ groundtruth_label_confidences,
+ multiclass_scores,
+ groundtruth_instance_masks,
+ groundtruth_keypoints,
+ ),
+ convert_class_logits_to_softmax: (multiclass_scores,),
+ }
+
+ return prep_func_arg_map
+
+
+def preprocess(tensor_dict,
+ preprocess_options,
+ func_arg_map=None,
+ preprocess_vars_cache=None):
+ """Preprocess images and bounding boxes.
+
+ Various types of preprocessing (to be implemented) based on the
+ preprocess_options dictionary e.g. "crop image" (affects image and possibly
+ boxes), "white balance image" (affects only image), etc. If self._options
+ is None, no preprocessing is done.
+
+ Args:
+ tensor_dict: dictionary that contains images, boxes, and can contain other
+ things as well.
+ images-> rank 4 float32 tensor contains
+ 1 image -> [1, height, width, 3].
+ with pixel values varying between [0, 1]
+ boxes-> rank 2 float32 tensor containing
+ the bounding boxes -> [N, 4].
+ Boxes are in normalized form meaning
+ their coordinates vary between [0, 1].
+ Each row is in the form
+ of [ymin, xmin, ymax, xmax].
+ preprocess_options: It is a list of tuples, where each tuple contains a
+ function and a dictionary that contains arguments and
+ their values.
+ func_arg_map: mapping from preprocessing functions to arguments that they
+ expect to receive and return.
+ preprocess_vars_cache: PreprocessorCache object that records previously
+ performed augmentations. Updated in-place. If this
+ function is called multiple times with the same
+ non-null cache, it will perform deterministically.
+
+ Returns:
+ tensor_dict: which contains the preprocessed images, bounding boxes, etc.
+
+ Raises:
+ ValueError: (a) If the functions passed to Preprocess
+ are not in func_arg_map.
+ (b) If the arguments that a function needs
+ do not exist in tensor_dict.
+ (c) If image in tensor_dict is not rank 4
+ """
+ if func_arg_map is None:
+ func_arg_map = get_default_func_arg_map()
+
+ # changes the images to image (rank 4 to rank 3) since the functions
+ # receive rank 3 tensor for image
+ if fields.InputDataFields.image in tensor_dict:
+ images = tensor_dict[fields.InputDataFields.image]
+ if len(images.get_shape()) != 4:
+ raise ValueError('images in tensor_dict should be rank 4')
+ image = tf.squeeze(images, axis=0)
+ tensor_dict[fields.InputDataFields.image] = image
+
+ # Preprocess inputs based on preprocess_options
+ for option in preprocess_options:
+ func, params = option
+ if func not in func_arg_map:
+ raise ValueError('The function %s does not exist in func_arg_map' %
+ (func.__name__))
+ arg_names = func_arg_map[func]
+ for a in arg_names:
+ if a is not None and a not in tensor_dict:
+ raise ValueError('The function %s requires argument %s' %
+ (func.__name__, a))
+
+ def get_arg(key):
+ return tensor_dict[key] if key is not None else None
+
+ args = [get_arg(a) for a in arg_names]
+ if preprocess_vars_cache is not None:
+ if six.PY2:
+ # pylint: disable=deprecated-method
+ arg_spec = inspect.getargspec(func)
+ # pylint: enable=deprecated-method
+ else:
+ arg_spec = inspect.getfullargspec(func)
+ if 'preprocess_vars_cache' in arg_spec.args:
+ params['preprocess_vars_cache'] = preprocess_vars_cache
+
+ results = func(*args, **params)
+ if not isinstance(results, (list, tuple)):
+ results = (results,)
+ # Removes None args since the return values will not contain those.
+ arg_names = [arg_name for arg_name in arg_names if arg_name is not None]
+ for res, arg_name in zip(results, arg_names):
+ tensor_dict[arg_name] = res
+
+ # changes the image to images (rank 3 to rank 4) to be compatible to what
+ # we received in the first place
+ if fields.InputDataFields.image in tensor_dict:
+ image = tensor_dict[fields.InputDataFields.image]
+ images = tf.expand_dims(image, 0)
+ tensor_dict[fields.InputDataFields.image] = images
+
+ return tensor_dict
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_cache.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_cache.py
new file mode 100644
index 00000000..706d44cd
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_cache.py
@@ -0,0 +1,107 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Records previous preprocessing operations and allows them to be repeated.
+
+Used with object_detection.core.preprocessor. Passing a PreprocessorCache
+into individual data augmentation functions or the general preprocess() function
+will store all randomly generated variables in the PreprocessorCache. When
+a preprocessor function is called multiple times with the same
+PreprocessorCache object, that function will perform the same augmentation
+on all calls.
+"""
+
+from collections import defaultdict
+
+
+class PreprocessorCache(object):
+ """Dictionary wrapper storing random variables generated during preprocessing.
+ """
+
+ # Constant keys representing different preprocessing functions
+ ROTATION90 = 'rotation90'
+ HORIZONTAL_FLIP = 'horizontal_flip'
+ VERTICAL_FLIP = 'vertical_flip'
+ PIXEL_VALUE_SCALE = 'pixel_value_scale'
+ IMAGE_SCALE = 'image_scale'
+ RGB_TO_GRAY = 'rgb_to_gray'
+ ADJUST_BRIGHTNESS = 'adjust_brightness'
+ ADJUST_CONTRAST = 'adjust_contrast'
+ ADJUST_HUE = 'adjust_hue'
+ ADJUST_SATURATION = 'adjust_saturation'
+ DISTORT_COLOR = 'distort_color'
+ STRICT_CROP_IMAGE = 'strict_crop_image'
+ CROP_IMAGE = 'crop_image'
+ PAD_IMAGE = 'pad_image'
+ CROP_TO_ASPECT_RATIO = 'crop_to_aspect_ratio'
+ RESIZE_METHOD = 'resize_method'
+ PAD_TO_ASPECT_RATIO = 'pad_to_aspect_ratio'
+ BLACK_PATCHES = 'black_patches'
+ ADD_BLACK_PATCH = 'add_black_patch'
+ SELECTOR = 'selector'
+ SELECTOR_TUPLES = 'selector_tuples'
+ SELF_CONCAT_IMAGE = 'self_concat_image'
+ SSD_CROP_SELECTOR_ID = 'ssd_crop_selector_id'
+ SSD_CROP_PAD_SELECTOR_ID = 'ssd_crop_pad_selector_id'
+ JPEG_QUALITY = 'jpeg_quality'
+ DOWNSCALE_TO_TARGET_PIXELS = 'downscale_to_target_pixels'
+ PATCH_GAUSSIAN = 'patch_gaussian'
+
+ # 27 permitted function ids
+ _VALID_FNS = [ROTATION90, HORIZONTAL_FLIP, VERTICAL_FLIP, PIXEL_VALUE_SCALE,
+ IMAGE_SCALE, RGB_TO_GRAY, ADJUST_BRIGHTNESS, ADJUST_CONTRAST,
+ ADJUST_HUE, ADJUST_SATURATION, DISTORT_COLOR, STRICT_CROP_IMAGE,
+ CROP_IMAGE, PAD_IMAGE, CROP_TO_ASPECT_RATIO, RESIZE_METHOD,
+ PAD_TO_ASPECT_RATIO, BLACK_PATCHES, ADD_BLACK_PATCH, SELECTOR,
+ SELECTOR_TUPLES, SELF_CONCAT_IMAGE, SSD_CROP_SELECTOR_ID,
+ SSD_CROP_PAD_SELECTOR_ID, JPEG_QUALITY,
+ DOWNSCALE_TO_TARGET_PIXELS, PATCH_GAUSSIAN]
+
+ def __init__(self):
+ self._history = defaultdict(dict)
+
+ def clear(self):
+ """Resets cache."""
+ self._history = defaultdict(dict)
+
+ def get(self, function_id, key):
+ """Gets stored value given a function id and key.
+
+ Args:
+ function_id: identifier for the preprocessing function used.
+ key: identifier for the variable stored.
+ Returns:
+ value: the corresponding value, expected to be a tensor or
+ nested structure of tensors.
+ Raises:
+ ValueError: if function_id is not one of the 23 valid function ids.
+ """
+ if function_id not in self._VALID_FNS:
+ raise ValueError('Function id not recognized: %s.' % str(function_id))
+ return self._history[function_id].get(key)
+
+ def update(self, function_id, key, value):
+ """Adds a value to the dictionary.
+
+ Args:
+ function_id: identifier for the preprocessing function used.
+ key: identifier for the variable stored.
+ value: the value to store, expected to be a tensor or nested structure
+ of tensors.
+ Raises:
+ ValueError: if function_id is not one of the 23 valid function ids.
+ """
+ if function_id not in self._VALID_FNS:
+ raise ValueError('Function id not recognized: %s.' % str(function_id))
+ self._history[function_id][key] = value
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_test.py
new file mode 100644
index 00000000..39167742
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/preprocessor_test.py
@@ -0,0 +1,3585 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.preprocessor."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from absl.testing import parameterized
+import numpy as np
+import six
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.core import preprocessor
+from object_detection.core import preprocessor_cache
+from object_detection.core import standard_fields as fields
+
+if six.PY2:
+ import mock # pylint: disable=g-import-not-at-top
+else:
+ from unittest import mock # pylint: disable=g-import-not-at-top
+
+
+class PreprocessorTest(tf.test.TestCase, parameterized.TestCase):
+
+ def createColorfulTestImage(self):
+ ch255 = tf.fill([1, 100, 200, 1], tf.constant(255, dtype=tf.uint8))
+ ch128 = tf.fill([1, 100, 200, 1], tf.constant(128, dtype=tf.uint8))
+ ch0 = tf.fill([1, 100, 200, 1], tf.constant(0, dtype=tf.uint8))
+ imr = tf.concat([ch255, ch0, ch0], 3)
+ img = tf.concat([ch255, ch255, ch0], 3)
+ imb = tf.concat([ch255, ch0, ch255], 3)
+ imw = tf.concat([ch128, ch128, ch128], 3)
+ imu = tf.concat([imr, img], 2)
+ imd = tf.concat([imb, imw], 2)
+ im = tf.concat([imu, imd], 1)
+ return im
+
+ def createTestImages(self):
+ images_r = tf.constant([[[128, 128, 128, 128], [0, 0, 128, 128],
+ [0, 128, 128, 128], [192, 192, 128, 128]]],
+ dtype=tf.uint8)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, 128, 128], [0, 0, 128, 128],
+ [0, 128, 192, 192], [192, 192, 128, 192]]],
+ dtype=tf.uint8)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[128, 128, 192, 0], [0, 0, 128, 192],
+ [0, 128, 128, 0], [192, 192, 192, 128]]],
+ dtype=tf.uint8)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def createEmptyTestBoxes(self):
+ boxes = tf.constant([[]], dtype=tf.float32)
+ return boxes
+
+ def createTestBoxes(self):
+ boxes = tf.constant(
+ [[0.0, 0.25, 0.75, 1.0], [0.25, 0.5, 0.75, 1.0]], dtype=tf.float32)
+ return boxes
+
+ def createTestGroundtruthWeights(self):
+ return tf.constant([1.0, 0.5], dtype=tf.float32)
+
+ def createTestMasks(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]],
+ [[255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def createTestKeypoints(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createTestKeypointsInsideCrop(self):
+ keypoints = np.array([
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ [[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createTestKeypointsOutsideCrop(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]],
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def createKeypointFlipPermutation(self):
+ return np.array([0, 2, 1], dtype=np.int32)
+
+ def createTestLabels(self):
+ labels = tf.constant([1, 2], dtype=tf.int32)
+ return labels
+
+ def createTestLabelsLong(self):
+ labels = tf.constant([1, 2, 4], dtype=tf.int32)
+ return labels
+
+ def createTestBoxesOutOfImage(self):
+ boxes = tf.constant(
+ [[-0.1, 0.25, 0.75, 1], [0.25, 0.5, 0.75, 1.1]], dtype=tf.float32)
+ return boxes
+
+ def createTestMultiClassScores(self):
+ return tf.constant([[1.0, 0.0], [0.5, 0.5]], dtype=tf.float32)
+
+ def expectedImagesAfterNormalization(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [-1, -1, 0, 0],
+ [-1, 0, 0, 0], [0.5, 0.5, 0, 0]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-1, -1, 0, 0], [-1, -1, 0, 0],
+ [-1, 0, 0.5, 0.5], [0.5, 0.5, 0, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0, 0, 0.5, -1], [-1, -1, 0, 0.5],
+ [-1, 0, 0, -1], [0.5, 0.5, 0.5, 0]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedMaxImageAfterColorScale(self):
+ images_r = tf.constant([[[0.1, 0.1, 0.1, 0.1], [-0.9, -0.9, 0.1, 0.1],
+ [-0.9, 0.1, 0.1, 0.1], [0.6, 0.6, 0.1, 0.1]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-0.9, -0.9, 0.1, 0.1], [-0.9, -0.9, 0.1, 0.1],
+ [-0.9, 0.1, 0.6, 0.6], [0.6, 0.6, 0.1, 0.6]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0.1, 0.1, 0.6, -0.9], [-0.9, -0.9, 0.1, 0.6],
+ [-0.9, 0.1, 0.1, -0.9], [0.6, 0.6, 0.6, 0.1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedMinImageAfterColorScale(self):
+ images_r = tf.constant([[[-0.1, -0.1, -0.1, -0.1], [-1, -1, -0.1, -0.1],
+ [-1, -0.1, -0.1, -0.1], [0.4, 0.4, -0.1, -0.1]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[-1, -1, -0.1, -0.1], [-1, -1, -0.1, -0.1],
+ [-1, -0.1, 0.4, 0.4], [0.4, 0.4, -0.1, 0.4]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-0.1, -0.1, 0.4, -1], [-1, -1, -0.1, 0.4],
+ [-1, -0.1, -0.1, -1], [0.4, 0.4, 0.4, -0.1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterLeftRightFlip(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [0, 0, -1, -1],
+ [0, 0, 0, -1], [0, 0, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, -1, -1], [0, 0, -1, -1],
+ [0.5, 0.5, 0, -1], [0.5, 0, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-1, 0.5, 0, 0], [0.5, 0, -1, -1],
+ [-1, 0, 0, -1], [0, 0.5, 0.5, 0.5]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterUpDownFlip(self):
+ images_r = tf.constant([[[0.5, 0.5, 0, 0], [-1, 0, 0, 0],
+ [-1, -1, 0, 0], [0, 0, 0, 0]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0.5, 0.5, 0, 0.5], [-1, 0, 0.5, 0.5],
+ [-1, -1, 0, 0], [-1, -1, 0, 0]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[0.5, 0.5, 0.5, 0], [-1, 0, 0, -1],
+ [-1, -1, 0, 0.5], [0, 0, 0.5, -1]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedImagesAfterRot90(self):
+ images_r = tf.constant([[[0, 0, 0, 0], [0, 0, 0, 0],
+ [0, -1, 0, 0.5], [0, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_r = tf.expand_dims(images_r, 3)
+ images_g = tf.constant([[[0, 0, 0.5, 0.5], [0, 0, 0.5, 0],
+ [-1, -1, 0, 0.5], [-1, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_g = tf.expand_dims(images_g, 3)
+ images_b = tf.constant([[[-1, 0.5, -1, 0], [0.5, 0, 0, 0.5],
+ [0, -1, 0, 0.5], [0, -1, -1, 0.5]]],
+ dtype=tf.float32)
+ images_b = tf.expand_dims(images_b, 3)
+ images = tf.concat([images_r, images_g, images_b], 3)
+ return images
+
+ def expectedBoxesAfterLeftRightFlip(self):
+ boxes = tf.constant([[0.0, 0.0, 0.75, 0.75], [0.25, 0.0, 0.75, 0.5]],
+ dtype=tf.float32)
+ return boxes
+
+ def expectedBoxesAfterUpDownFlip(self):
+ boxes = tf.constant([[0.25, 0.25, 1.0, 1.0], [0.25, 0.5, 0.75, 1.0]],
+ dtype=tf.float32)
+ return boxes
+
+ def expectedBoxesAfterRot90(self):
+ boxes = tf.constant(
+ [[0.0, 0.0, 0.75, 0.75], [0.0, 0.25, 0.5, 0.75]], dtype=tf.float32)
+ return boxes
+
+ def expectedMasksAfterLeftRightFlip(self):
+ mask = np.array([
+ [[0.0, 0.0, 255.0],
+ [0.0, 0.0, 255.0],
+ [0.0, 0.0, 255.0]],
+ [[0.0, 255.0, 255.0],
+ [0.0, 255.0, 255.0],
+ [0.0, 255.0, 255.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedMasksAfterUpDownFlip(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]],
+ [[255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedMasksAfterRot90(self):
+ mask = np.array([
+ [[0.0, 0.0, 0.0],
+ [0.0, 0.0, 0.0],
+ [255.0, 255.0, 255.0]],
+ [[0.0, 0.0, 0.0],
+ [255.0, 255.0, 255.0],
+ [255.0, 255.0, 255.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedLabelScoresAfterThresholding(self):
+ return tf.constant([1.0], dtype=tf.float32)
+
+ def expectedBoxesAfterThresholding(self):
+ return tf.constant([[0.0, 0.25, 0.75, 1.0]], dtype=tf.float32)
+
+ def expectedLabelsAfterThresholding(self):
+ return tf.constant([1], dtype=tf.float32)
+
+ def expectedMultiClassScoresAfterThresholding(self):
+ return tf.constant([[1.0, 0.0]], dtype=tf.float32)
+
+ def expectedMasksAfterThresholding(self):
+ mask = np.array([
+ [[255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0],
+ [255.0, 0.0, 0.0]]])
+ return tf.constant(mask, dtype=tf.float32)
+
+ def expectedKeypointsAfterThresholding(self):
+ keypoints = np.array([
+ [[0.1, 0.1], [0.2, 0.2], [0.3, 0.3]]
+ ])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def expectedLabelScoresAfterThresholdingWithMissingScore(self):
+ return tf.constant([np.nan], dtype=tf.float32)
+
+ def expectedBoxesAfterThresholdingWithMissingScore(self):
+ return tf.constant([[0.25, 0.5, 0.75, 1]], dtype=tf.float32)
+
+ def expectedLabelsAfterThresholdingWithMissingScore(self):
+ return tf.constant([2], dtype=tf.float32)
+
+ def expectedLabelScoresAfterDropping(self):
+ return tf.constant([0.5], dtype=tf.float32)
+
+ def expectedBoxesAfterDropping(self):
+ return tf.constant([[0.25, 0.5, 0.75, 1.0]], dtype=tf.float32)
+
+ def expectedLabelsAfterDropping(self):
+ return tf.constant([2], dtype=tf.float32)
+
+ def expectedMultiClassScoresAfterDropping(self):
+ return tf.constant([[0.5, 0.5]], dtype=tf.float32)
+
+ def expectedMasksAfterDropping(self):
+ masks = np.array([[[255.0, 255.0, 0.0], [255.0, 255.0, 0.0],
+ [255.0, 255.0, 0.0]]])
+ return tf.constant(masks, dtype=tf.float32)
+
+ def expectedKeypointsAfterDropping(self):
+ keypoints = np.array([[[0.4, 0.4], [0.5, 0.5], [0.6, 0.6]]])
+ return tf.constant(keypoints, dtype=tf.float32)
+
+ def expectedLabelsAfterRemapping(self):
+ return tf.constant([3, 3, 4], dtype=tf.float32)
+
+ def testRgbToGrayscale(self):
+ images = self.createTestImages()
+ grayscale_images = preprocessor._rgb_to_grayscale(images)
+ expected_images = tf.image.rgb_to_grayscale(images)
+ with self.test_session() as sess:
+ (grayscale_images, expected_images) = sess.run(
+ [grayscale_images, expected_images])
+ self.assertAllEqual(expected_images, grayscale_images)
+
+ def testNormalizeImage(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 256,
+ 'target_minval': -1,
+ 'target_maxval': 1
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ images_expected = self.expectedImagesAfterNormalization()
+
+ with self.test_session() as sess:
+ (images_, images_expected_) = sess.run(
+ [images, images_expected])
+ images_shape_ = images_.shape
+ images_expected_shape_ = images_expected_.shape
+ expected_shape = [1, 4, 4, 3]
+ self.assertAllEqual(images_expected_shape_, images_shape_)
+ self.assertAllEqual(images_shape_, expected_shape)
+ self.assertAllClose(images_, images_expected_)
+
+ def testRetainBoxesAboveThreshold(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (retained_boxes, retained_labels,
+ retained_weights) = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, threshold=0.6)
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_, retained_weights_,
+ expected_retained_boxes_, expected_retained_labels_,
+ expected_retained_weights_) = sess.run([
+ retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterThresholding(),
+ self.expectedLabelsAfterThresholding(),
+ self.expectedLabelScoresAfterThresholding()])
+ self.assertAllClose(
+ retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(
+ retained_labels_, expected_retained_labels_)
+ self.assertAllClose(
+ retained_weights_, expected_retained_weights_)
+
+ def testRetainBoxesAboveThresholdWithMultiClassScores(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+ (_, _, _,
+ retained_multiclass_scores) = preprocessor.retain_boxes_above_threshold(
+ boxes,
+ labels,
+ weights,
+ multiclass_scores=multiclass_scores,
+ threshold=0.6)
+ with self.test_session() as sess:
+ (retained_multiclass_scores_,
+ expected_retained_multiclass_scores_) = sess.run([
+ retained_multiclass_scores,
+ self.expectedMultiClassScoresAfterThresholding()
+ ])
+
+ self.assertAllClose(retained_multiclass_scores_,
+ expected_retained_multiclass_scores_)
+
+ def testRetainBoxesAboveThresholdWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+ _, _, _, retained_masks = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, masks, threshold=0.6)
+ with self.test_session() as sess:
+ retained_masks_, expected_retained_masks_ = sess.run([
+ retained_masks, self.expectedMasksAfterThresholding()])
+
+ self.assertAllClose(
+ retained_masks_, expected_retained_masks_)
+
+ def testRetainBoxesAboveThresholdWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ (_, _, _, retained_keypoints) = preprocessor.retain_boxes_above_threshold(
+ boxes, labels, weights, keypoints=keypoints, threshold=0.6)
+ with self.test_session() as sess:
+ (retained_keypoints_,
+ expected_retained_keypoints_) = sess.run([
+ retained_keypoints,
+ self.expectedKeypointsAfterThresholding()])
+
+ self.assertAllClose(
+ retained_keypoints_, expected_retained_keypoints_)
+
+ def testDropLabelProbabilistically(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (retained_boxes, retained_labels,
+ retained_weights) = preprocessor.drop_label_probabilistically(
+ boxes, labels, weights, dropped_label=1, drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_, retained_weights_,
+ expected_retained_boxes_, expected_retained_labels_,
+ expected_retained_weights_) = sess.run([
+ retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterDropping(),
+ self.expectedLabelsAfterDropping(),
+ self.expectedLabelScoresAfterDropping()
+ ])
+ self.assertAllClose(retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(retained_labels_, expected_retained_labels_)
+ self.assertAllClose(retained_weights_, expected_retained_weights_)
+
+ def testDropLabelProbabilisticallyWithProbabilityHalf(self):
+ # Boxes contain one box of label 2 and one box of label 1 which should be
+ # dropped ~50% of the time.
+ num_tests = 100
+ total = 0
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ (_, retained_labels, _) = preprocessor.drop_label_probabilistically(
+ boxes, labels, weights, dropped_label=1, drop_probability=0.5)
+ for _ in range(num_tests):
+ with self.test_session() as sess:
+ retained_labels_ = sess.run(retained_labels)
+ total += len(retained_labels_)
+ self.assertIn(2, retained_labels_)
+ av = total * 1.0 / num_tests
+ self.assertGreater(av, 1.40)
+ self.assertLess(av, 1.50)
+
+ def testDropLabelProbabilisticallyWithMultiClassScores(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+ (_, _, _,
+ retained_multiclass_scores) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ multiclass_scores=multiclass_scores,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_multiclass_scores_,
+ expected_retained_multiclass_scores_) = sess.run([
+ retained_multiclass_scores,
+ self.expectedMultiClassScoresAfterDropping()
+ ])
+ self.assertAllClose(retained_multiclass_scores_,
+ expected_retained_multiclass_scores_)
+
+ def testDropLabelProbabilisticallyWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+ (_, _, _, retained_masks) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ masks=masks,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_masks_, expected_retained_masks_) = sess.run(
+ [retained_masks, self.expectedMasksAfterDropping()])
+ self.assertAllClose(retained_masks_, expected_retained_masks_)
+
+ def testDropLabelProbabilisticallyWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ (_, _, _, retained_keypoints) = preprocessor.drop_label_probabilistically(
+ boxes,
+ labels,
+ weights,
+ keypoints=keypoints,
+ dropped_label=1,
+ drop_probability=1.0)
+ with self.test_session() as sess:
+ (retained_keypoints_, expected_retained_keypoints_) = sess.run(
+ [retained_keypoints,
+ self.expectedKeypointsAfterDropping()])
+ self.assertAllClose(retained_keypoints_, expected_retained_keypoints_)
+
+ def testRemapLabels(self):
+ labels = self.createTestLabelsLong()
+ remapped_labels = preprocessor.remap_labels(labels, [1, 2], 3)
+ with self.test_session() as sess:
+ (remapped_labels_, expected_remapped_labels_) = sess.run(
+ [remapped_labels, self.expectedLabelsAfterRemapping()])
+ self.assertAllClose(remapped_labels_, expected_remapped_labels_)
+
+ def testFlipBoxesLeftRight(self):
+ boxes = self.createTestBoxes()
+ flipped_boxes = preprocessor._flip_boxes_left_right(boxes)
+ expected_boxes = self.expectedBoxesAfterLeftRightFlip()
+ with self.test_session() as sess:
+ flipped_boxes, expected_boxes = sess.run([flipped_boxes, expected_boxes])
+ self.assertAllEqual(flipped_boxes.flatten(), expected_boxes.flatten())
+
+ def testFlipBoxesUpDown(self):
+ boxes = self.createTestBoxes()
+ flipped_boxes = preprocessor._flip_boxes_up_down(boxes)
+ expected_boxes = self.expectedBoxesAfterUpDownFlip()
+ with self.test_session() as sess:
+ flipped_boxes, expected_boxes = sess.run([flipped_boxes, expected_boxes])
+ self.assertAllEqual(flipped_boxes.flatten(), expected_boxes.flatten())
+
+ def testRot90Boxes(self):
+ boxes = self.createTestBoxes()
+ rotated_boxes = preprocessor._rot90_boxes(boxes)
+ expected_boxes = self.expectedBoxesAfterRot90()
+ with self.test_session() as sess:
+ rotated_boxes, expected_boxes = sess.run([rotated_boxes, expected_boxes])
+ self.assertAllEqual(rotated_boxes.flatten(), expected_boxes.flatten())
+
+ def testFlipMasksLeftRight(self):
+ test_mask = self.createTestMasks()
+ flipped_mask = preprocessor._flip_masks_left_right(test_mask)
+ expected_mask = self.expectedMasksAfterLeftRightFlip()
+ with self.test_session() as sess:
+ flipped_mask, expected_mask = sess.run([flipped_mask, expected_mask])
+ self.assertAllEqual(flipped_mask.flatten(), expected_mask.flatten())
+
+ def testFlipMasksUpDown(self):
+ test_mask = self.createTestMasks()
+ flipped_mask = preprocessor._flip_masks_up_down(test_mask)
+ expected_mask = self.expectedMasksAfterUpDownFlip()
+ with self.test_session() as sess:
+ flipped_mask, expected_mask = sess.run([flipped_mask, expected_mask])
+ self.assertAllEqual(flipped_mask.flatten(), expected_mask.flatten())
+
+ def testRot90Masks(self):
+ test_mask = self.createTestMasks()
+ rotated_mask = preprocessor._rot90_masks(test_mask)
+ expected_mask = self.expectedMasksAfterRot90()
+ with self.test_session() as sess:
+ rotated_mask, expected_mask = sess.run([rotated_mask, expected_mask])
+ self.assertAllEqual(rotated_mask.flatten(), expected_mask.flatten())
+
+ def _testPreprocessorCache(self,
+ preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False,
+ num_runs=4):
+ cache = preprocessor_cache.PreprocessorCache()
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ weights = self.createTestGroundtruthWeights()
+ classes = self.createTestLabels()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=test_masks, include_keypoints=test_keypoints)
+ out = []
+ for i in range(num_runs):
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ num_outputs = 1
+ if test_boxes:
+ tensor_dict[fields.InputDataFields.groundtruth_boxes] = boxes
+ tensor_dict[fields.InputDataFields.groundtruth_classes] = classes
+ num_outputs += 1
+ if test_masks:
+ tensor_dict[fields.InputDataFields.groundtruth_instance_masks] = masks
+ num_outputs += 1
+ if test_keypoints:
+ tensor_dict[fields.InputDataFields.groundtruth_keypoints] = keypoints
+ num_outputs += 1
+ out.append(preprocessor.preprocess(
+ tensor_dict, preprocess_options, preprocessor_arg_map, cache))
+
+ with self.test_session() as sess:
+ to_run = []
+ for i in range(num_runs):
+ to_run.append(out[i][fields.InputDataFields.image])
+ if test_boxes:
+ to_run.append(out[i][fields.InputDataFields.groundtruth_boxes])
+ if test_masks:
+ to_run.append(
+ out[i][fields.InputDataFields.groundtruth_instance_masks])
+ if test_keypoints:
+ to_run.append(out[i][fields.InputDataFields.groundtruth_keypoints])
+
+ out_array = sess.run(to_run)
+ for i in range(num_outputs, len(out_array)):
+ self.assertAllClose(out_array[i], out_array[i - num_outputs])
+
+ def testRandomHorizontalFlip(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterLeftRightFlip()
+ boxes_expected1 = self.expectedBoxesAfterLeftRightFlip()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomHorizontalFlipWithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterLeftRightFlip()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomHorizontalFlipWithCache(self):
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ preprocess_options = [
+ (preprocessor.random_horizontal_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomHorizontalFlipWithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_horizontal_flip, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocess_options = [
+ (preprocessor.random_horizontal_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomVerticalFlip(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterUpDownFlip()
+ boxes_expected1 = self.expectedBoxesAfterUpDownFlip()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomVerticalFlipWithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterUpDownFlip()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomVerticalFlipWithCache(self):
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ preprocess_options = [
+ (preprocessor.random_vertical_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomVerticalFlipWithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_vertical_flip, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ keypoint_flip_permutation = self.createKeypointFlipPermutation()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocess_options = [
+ (preprocessor.random_vertical_flip,
+ {'keypoint_flip_permutation': keypoint_flip_permutation})]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomRotation90(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterRot90()
+ boxes_expected1 = self.expectedBoxesAfterRot90()
+ images_expected2 = images
+ boxes_expected2 = boxes
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ boxes_diff1 = tf.squared_difference(boxes, boxes_expected1)
+ boxes_diff2 = tf.squared_difference(boxes, boxes_expected2)
+ boxes_diff = tf.multiply(boxes_diff1, boxes_diff2)
+ boxes_diff_expected = tf.zeros_like(boxes_diff)
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_diff_,
+ boxes_diff_expected_) = sess.run([images_diff, images_diff_expected,
+ boxes_diff, boxes_diff_expected])
+ self.assertAllClose(boxes_diff_, boxes_diff_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomRotation90WithEmptyBoxes(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ images = self.expectedImagesAfterNormalization()
+ boxes = self.createEmptyTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ images_expected1 = self.expectedImagesAfterRot90()
+ boxes_expected = self.createEmptyTestBoxes()
+ images_expected2 = images
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images = tensor_dict[fields.InputDataFields.image]
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+
+ images_diff1 = tf.squared_difference(images, images_expected1)
+ images_diff2 = tf.squared_difference(images, images_expected2)
+ images_diff = tf.multiply(images_diff1, images_diff2)
+ images_diff_expected = tf.zeros_like(images_diff)
+
+ with self.test_session() as sess:
+ (images_diff_, images_diff_expected_, boxes_,
+ boxes_expected_) = sess.run([images_diff, images_diff_expected, boxes,
+ boxes_expected])
+ self.assertAllClose(boxes_, boxes_expected_)
+ self.assertAllClose(images_diff_, images_diff_expected_)
+
+ def testRandomRotation90WithCache(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomRotation90WithMaskAndKeypoints(self):
+ preprocess_options = [(preprocessor.random_rotation90, {})]
+ image_height = 3
+ image_width = 3
+ images = tf.random_uniform([1, image_height, image_width, 3])
+ boxes = self.createTestBoxes()
+ masks = self.createTestMasks()
+ keypoints = self.createTestKeypoints()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True, include_keypoints=True)
+ tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocess_options, func_arg_map=preprocessor_arg_map)
+ boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ masks = tensor_dict[fields.InputDataFields.groundtruth_instance_masks]
+ keypoints = tensor_dict[fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ boxes, masks, keypoints = sess.run([boxes, masks, keypoints])
+ self.assertTrue(boxes is not None)
+ self.assertTrue(masks is not None)
+ self.assertTrue(keypoints is not None)
+
+ def testRandomPixelValueScale(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_pixel_value_scale, {}))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_min = tf.cast(images, dtype=tf.float32) * 0.9 / 255.0
+ images_max = tf.cast(images, dtype=tf.float32) * 1.1 / 255.0
+ images = tensor_dict[fields.InputDataFields.image]
+ values_greater = tf.greater_equal(images, images_min)
+ values_less = tf.less_equal(images, images_max)
+ values_true = tf.fill([1, 4, 4, 3], True)
+ with self.test_session() as sess:
+ (values_greater_, values_less_, values_true_) = sess.run(
+ [values_greater, values_less, values_true])
+ self.assertAllClose(values_greater_, values_true_)
+ self.assertAllClose(values_less_, values_true_)
+
+ def testRandomPixelValueScaleWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_pixel_value_scale, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomImageScale(self):
+ preprocess_options = [(preprocessor.random_image_scale, {})]
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images_scaled = tensor_dict[fields.InputDataFields.image]
+ images_original_shape = tf.shape(images_original)
+ images_scaled_shape = tf.shape(images_scaled)
+ with self.test_session() as sess:
+ (images_original_shape_, images_scaled_shape_) = sess.run(
+ [images_original_shape, images_scaled_shape])
+ self.assertTrue(
+ images_original_shape_[1] * 0.5 <= images_scaled_shape_[1])
+ self.assertTrue(
+ images_original_shape_[1] * 2.0 >= images_scaled_shape_[1])
+ self.assertTrue(
+ images_original_shape_[2] * 0.5 <= images_scaled_shape_[2])
+ self.assertTrue(
+ images_original_shape_[2] * 2.0 >= images_scaled_shape_[2])
+
+ def testRandomImageScaleWithCache(self):
+ preprocess_options = [(preprocessor.random_image_scale, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomRGBtoGray(self):
+ preprocess_options = [(preprocessor.random_rgb_to_gray, {})]
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocess_options)
+ images_gray = tensor_dict[fields.InputDataFields.image]
+ images_gray_r, images_gray_g, images_gray_b = tf.split(
+ value=images_gray, num_or_size_splits=3, axis=3)
+ images_r, images_g, images_b = tf.split(
+ value=images_original, num_or_size_splits=3, axis=3)
+ images_r_diff1 = tf.squared_difference(
+ tf.cast(images_r, dtype=tf.float32),
+ tf.cast(images_gray_r, dtype=tf.float32))
+ images_r_diff2 = tf.squared_difference(
+ tf.cast(images_gray_r, dtype=tf.float32),
+ tf.cast(images_gray_g, dtype=tf.float32))
+ images_r_diff = tf.multiply(images_r_diff1, images_r_diff2)
+ images_g_diff1 = tf.squared_difference(
+ tf.cast(images_g, dtype=tf.float32),
+ tf.cast(images_gray_g, dtype=tf.float32))
+ images_g_diff2 = tf.squared_difference(
+ tf.cast(images_gray_g, dtype=tf.float32),
+ tf.cast(images_gray_b, dtype=tf.float32))
+ images_g_diff = tf.multiply(images_g_diff1, images_g_diff2)
+ images_b_diff1 = tf.squared_difference(
+ tf.cast(images_b, dtype=tf.float32),
+ tf.cast(images_gray_b, dtype=tf.float32))
+ images_b_diff2 = tf.squared_difference(
+ tf.cast(images_gray_b, dtype=tf.float32),
+ tf.cast(images_gray_r, dtype=tf.float32))
+ images_b_diff = tf.multiply(images_b_diff1, images_b_diff2)
+ image_zero1 = tf.constant(0, dtype=tf.float32, shape=[1, 4, 4, 1])
+ with self.test_session() as sess:
+ (images_r_diff_, images_g_diff_, images_b_diff_, image_zero1_) = sess.run(
+ [images_r_diff, images_g_diff, images_b_diff, image_zero1])
+ self.assertAllClose(images_r_diff_, image_zero1_)
+ self.assertAllClose(images_g_diff_, image_zero1_)
+ self.assertAllClose(images_b_diff_, image_zero1_)
+
+ def testRandomRGBtoGrayWithCache(self):
+ preprocess_options = [(
+ preprocessor.random_rgb_to_gray, {'probability': 0.5})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustBrightness(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_brightness, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_bright = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_bright_shape = tf.shape(images_bright)
+ with self.test_session() as sess:
+ (image_original_shape_, image_bright_shape_) = sess.run(
+ [image_original_shape, image_bright_shape])
+ self.assertAllEqual(image_original_shape_, image_bright_shape_)
+
+ def testRandomAdjustBrightnessWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_brightness, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustContrast(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_contrast, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_contrast = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_contrast_shape = tf.shape(images_contrast)
+ with self.test_session() as sess:
+ (image_original_shape_, image_contrast_shape_) = sess.run(
+ [image_original_shape, image_contrast_shape])
+ self.assertAllEqual(image_original_shape_, image_contrast_shape_)
+
+ def testRandomAdjustContrastWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_contrast, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomAdjustHue(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_adjust_hue, {}))
+ images_original = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_hue = tensor_dict[fields.InputDataFields.image]
+ image_original_shape = tf.shape(images_original)
+ image_hue_shape = tf.shape(images_hue)
+ with self.test_session() as sess:
+ (image_original_shape_, image_hue_shape_) = sess.run(
+ [image_original_shape, image_hue_shape])
+ self.assertAllEqual(image_original_shape_, image_hue_shape_)
+
+ def testRandomAdjustHueWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_adjust_hue, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomDistortColor(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_distort_color, {}))
+ images_original = self.createTestImages()
+ images_original_shape = tf.shape(images_original)
+ tensor_dict = {fields.InputDataFields.image: images_original}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images_distorted_color = tensor_dict[fields.InputDataFields.image]
+ images_distorted_color_shape = tf.shape(images_distorted_color)
+ with self.test_session() as sess:
+ (images_original_shape_, images_distorted_color_shape_) = sess.run(
+ [images_original_shape, images_distorted_color_shape])
+ self.assertAllEqual(images_original_shape_, images_distorted_color_shape_)
+
+ def testRandomDistortColorWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_distort_color, {}))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=False,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomJitterBoxes(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.random_jitter_boxes, {}))
+ boxes = self.createTestBoxes()
+ boxes_shape = tf.shape(boxes)
+ tensor_dict = {fields.InputDataFields.groundtruth_boxes: boxes}
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ distorted_boxes = tensor_dict[fields.InputDataFields.groundtruth_boxes]
+ distorted_boxes_shape = tf.shape(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_shape_, distorted_boxes_shape_) = sess.run(
+ [boxes_shape, distorted_boxes_shape])
+ self.assertAllEqual(boxes_shape_, distorted_boxes_shape_)
+
+ def testRandomCropImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ self.assertEqual(3, distorted_images.get_shape()[3])
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithCache(self):
+ preprocess_options = [(preprocessor.random_rgb_to_gray,
+ {'probability': 0.5}),
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,
+ }),
+ (preprocessor.random_crop_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRandomCropImageGrayscale(self):
+ preprocessing_options = [(preprocessor.rgb_to_gray, {}),
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,
+ }),
+ (preprocessor.random_crop_image, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ self.assertEqual(1, distorted_images.get_shape()[3])
+
+ with self.test_session() as sess:
+ session_results = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = session_results
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithBoxOutOfImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxesOutOfImage()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testRandomCropImageWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_image, {
+ 'random_coef': 1.0
+ })]
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ boxes_shape = tf.shape(boxes)
+ distorted_boxes_shape = tf.shape(distorted_boxes)
+ images_shape = tf.shape(images)
+ distorted_images_shape = tf.shape(distorted_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, distorted_boxes_shape_, images_shape_,
+ distorted_images_shape_, images_, distorted_images_,
+ boxes_, distorted_boxes_, labels_, distorted_labels_,
+ weights_, distorted_weights_) = sess.run(
+ [boxes_shape, distorted_boxes_shape, images_shape,
+ distorted_images_shape, images, distorted_images,
+ boxes, distorted_boxes, labels, distorted_labels,
+ weights, distorted_weights])
+ self.assertAllEqual(boxes_shape_, distorted_boxes_shape_)
+ self.assertAllEqual(images_shape_, distorted_images_shape_)
+ self.assertAllClose(images_, distorted_images_)
+ self.assertAllClose(boxes_, distorted_boxes_)
+ self.assertAllEqual(labels_, distorted_labels_)
+ self.assertAllEqual(weights_, distorted_weights_)
+
+ def testRandomCropWithMockSampleDistortedBoundingBox(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createColorfulTestImage()
+ boxes = tf.constant([[0.1, 0.1, 0.8, 0.3],
+ [0.2, 0.4, 0.75, 0.75],
+ [0.3, 0.1, 0.4, 0.7]], dtype=tf.float32)
+ labels = tf.constant([1, 7, 11], dtype=tf.int32)
+ weights = tf.constant([1.0, 0.5, 0.6], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box') as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (tf.constant(
+ [6, 143, 0], dtype=tf.int32), tf.constant(
+ [190, 237, -1], dtype=tf.int32), tf.constant(
+ [[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ expected_boxes = tf.constant([[0.178947, 0.07173, 0.75789469, 0.66244733],
+ [0.28421, 0.0, 0.38947365, 0.57805908]],
+ dtype=tf.float32)
+ expected_labels = tf.constant([7, 11], dtype=tf.int32)
+ expected_weights = tf.constant([0.5, 0.6], dtype=tf.float32)
+
+ with self.test_session() as sess:
+ (distorted_boxes_, distorted_labels_, distorted_weights_,
+ expected_boxes_, expected_labels_, expected_weights_) = sess.run(
+ [distorted_boxes, distorted_labels, distorted_weights,
+ expected_boxes, expected_labels, expected_weights])
+ self.assertAllClose(distorted_boxes_, expected_boxes_)
+ self.assertAllEqual(distorted_labels_, expected_labels_)
+ self.assertAllEqual(distorted_weights_, expected_weights_)
+
+ def testRandomCropWithoutClipBoxes(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createColorfulTestImage()
+ boxes = tf.constant([[0.1, 0.1, 0.8, 0.3],
+ [0.2, 0.4, 0.75, 0.75],
+ [0.3, 0.1, 0.4, 0.7]], dtype=tf.float32)
+ keypoints = tf.constant([
+ [[0.1, 0.1], [0.8, 0.3]],
+ [[0.2, 0.4], [0.75, 0.75]],
+ [[0.3, 0.1], [0.4, 0.7]],
+ ], dtype=tf.float32)
+ labels = tf.constant([1, 7, 11], dtype=tf.int32)
+ weights = tf.constant([1.0, 0.5, 0.6], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {
+ 'clip_boxes': False,
+ })]
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box') as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (tf.constant(
+ [6, 143, 0], dtype=tf.int32), tf.constant(
+ [190, 237, -1], dtype=tf.int32), tf.constant(
+ [[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_weights = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+ expected_boxes = tf.constant(
+ [[0.178947, 0.07173, 0.75789469, 0.66244733],
+ [0.28421, -0.434599, 0.38947365, 0.57805908]],
+ dtype=tf.float32)
+ expected_keypoints = tf.constant(
+ [[[0.178947, 0.07173], [0.75789469, 0.66244733]],
+ [[0.28421, -0.434599], [0.38947365, 0.57805908]]],
+ dtype=tf.float32)
+ expected_labels = tf.constant([7, 11], dtype=tf.int32)
+ expected_weights = tf.constant([0.5, 0.6], dtype=tf.float32)
+
+ with self.test_session() as sess:
+ (distorted_boxes_, distorted_keypoints_, distorted_labels_,
+ distorted_weights_, expected_boxes_, expected_keypoints_,
+ expected_labels_, expected_weights_) = sess.run(
+ [distorted_boxes, distorted_keypoints, distorted_labels,
+ distorted_weights, expected_boxes, expected_keypoints,
+ expected_labels, expected_weights])
+ self.assertAllClose(distorted_boxes_, expected_boxes_)
+ self.assertAllClose(distorted_keypoints_, expected_keypoints_)
+ self.assertAllEqual(distorted_labels_, expected_labels_)
+ self.assertAllEqual(distorted_weights_, expected_weights_)
+
+ def testRandomCropImageWithMultiClassScores(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_crop_image, {}))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.multiclass_scores: multiclass_scores
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_multiclass_scores = distorted_tensor_dict[
+ fields.InputDataFields.multiclass_scores]
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ multiclass_scores_rank = tf.rank(multiclass_scores)
+ distorted_multiclass_scores_rank = tf.rank(distorted_multiclass_scores)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_, multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_,
+ distorted_multiclass_scores_) = sess.run([
+ boxes_rank, distorted_boxes, distorted_boxes_rank, images_rank,
+ distorted_images_rank, multiclass_scores_rank,
+ distorted_multiclass_scores_rank, distorted_multiclass_scores
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+ self.assertAllEqual(multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_)
+ self.assertAllEqual(distorted_boxes_.shape[0],
+ distorted_multiclass_scores_.shape[0])
+
+ def testStrictRandomCropImageWithGroundtruthWeights(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_groundtruth_weights = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_groundtruth_weights = (
+ sess.run(
+ [new_image, new_boxes, new_labels, new_groundtruth_weights])
+ )
+
+ expected_boxes = np.array(
+ [[0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0]], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllEqual(new_groundtruth_weights, [1.0, 0.5])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+
+ def testStrictRandomCropImageWithMasks(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_weights, new_masks = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights, masks=masks))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_weights, new_masks = sess.run(
+ [new_image, new_boxes, new_labels, new_weights, new_masks])
+ expected_boxes = np.array(
+ [[0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0]], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllEqual(new_masks.shape, [2, 190, 237])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+
+ def testStrictRandomCropImageWithKeypoints(self):
+ image = self.createColorfulTestImage()[0]
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ new_image, new_boxes, new_labels, new_weights, new_keypoints = (
+ preprocessor._strict_random_crop_image(
+ image, boxes, labels, weights, keypoints=keypoints))
+ with self.test_session() as sess:
+ new_image, new_boxes, new_labels, new_weights, new_keypoints = sess.run(
+ [new_image, new_boxes, new_labels, new_weights, new_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]]
+ ], dtype=np.float32)
+ self.assertAllEqual(new_image.shape, [190, 237, 3])
+ self.assertAllClose(
+ new_boxes.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ new_keypoints.flatten(), expected_keypoints.flatten())
+
+ def testRunRandomCropImageWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks,
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_masks])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_masks_.shape, [2, 190, 237])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+
+ def testRunRandomCropImageWithKeypointsInsideCrop(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypointsInsideCrop()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]],
+ [[0.38947368, 0.07173],
+ [0.49473682, 0.24050637],
+ [0.60000002, 0.40928277]]
+ ])
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ distorted_keypoints_.flatten(), expected_keypoints.flatten())
+
+ def testRunRandomCropImageWithKeypointsOutsideCrop(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypointsOutsideCrop()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_image, {})]
+
+ with mock.patch.object(
+ tf.image,
+ 'sample_distorted_bounding_box'
+ ) as mock_sample_distorted_bounding_box:
+ mock_sample_distorted_bounding_box.return_value = (
+ tf.constant([6, 143, 0], dtype=tf.int32),
+ tf.constant([190, 237, -1], dtype=tf.int32),
+ tf.constant([[[0.03, 0.3575, 0.98, 0.95]]], dtype=tf.float32))
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run(
+ [distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints])
+
+ expected_boxes = np.array([
+ [0.0, 0.0, 0.75789469, 1.0],
+ [0.23157893, 0.24050637, 0.75789469, 1.0],
+ ], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ [[np.nan, np.nan],
+ [np.nan, np.nan],
+ [np.nan, np.nan]],
+ ])
+ self.assertAllEqual(distorted_image_.shape, [1, 190, 237, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(
+ distorted_boxes_.flatten(), expected_boxes.flatten())
+ self.assertAllClose(
+ distorted_keypoints_.flatten(), expected_keypoints.flatten())
+
+ def testRunRetainBoxesAboveThreshold(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map()
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_boxes = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ retained_labels = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ retained_weights = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_weights]
+
+ with self.test_session() as sess:
+ (retained_boxes_, retained_labels_,
+ retained_weights_, expected_retained_boxes_,
+ expected_retained_labels_, expected_retained_weights_) = sess.run(
+ [retained_boxes, retained_labels, retained_weights,
+ self.expectedBoxesAfterThresholding(),
+ self.expectedLabelsAfterThresholding(),
+ self.expectedLabelScoresAfterThresholding()])
+
+ self.assertAllClose(retained_boxes_, expected_retained_boxes_)
+ self.assertAllClose(retained_labels_, expected_retained_labels_)
+ self.assertAllClose(
+ retained_weights_, expected_retained_weights_)
+
+ def testRunRetainBoxesAboveThresholdWithMasks(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = self.createTestMasks()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_label_weights=True,
+ include_instance_masks=True)
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_masks = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+
+ with self.test_session() as sess:
+ (retained_masks_, expected_masks_) = sess.run(
+ [retained_masks,
+ self.expectedMasksAfterThresholding()])
+ self.assertAllClose(retained_masks_, expected_masks_)
+
+ def testRunRetainBoxesAboveThresholdWithKeypoints(self):
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [
+ (preprocessor.retain_boxes_above_threshold, {'threshold': 0.6})
+ ]
+
+ retained_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ retained_keypoints = retained_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+
+ with self.test_session() as sess:
+ (retained_keypoints_, expected_keypoints_) = sess.run(
+ [retained_keypoints,
+ self.expectedKeypointsAfterThresholding()])
+ self.assertAllClose(retained_keypoints_, expected_keypoints_)
+
+ def testRandomCropToAspectRatioWithCache(self):
+ preprocess_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testRunRandomCropToAspectRatioWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+
+ with mock.patch.object(preprocessor,
+ '_random_integer') as mock_random_integer:
+ mock_random_integer.return_value = tf.constant(0, dtype=tf.int32)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels, distorted_masks
+ ])
+
+ expected_boxes = np.array([0.0, 0.5, 0.75, 1.0], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 200, 200, 3])
+ self.assertAllEqual(distorted_labels_, [1])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllEqual(distorted_masks_.shape, [1, 200, 200])
+
+ def testRunRandomCropToAspectRatioWithKeypoints(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {})]
+
+ with mock.patch.object(preprocessor,
+ '_random_integer') as mock_random_integer:
+ mock_random_integer.return_value = tf.constant(0, dtype=tf.int32)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints
+ ])
+
+ expected_boxes = np.array([0.0, 0.5, 0.75, 1.0], dtype=np.float32)
+ expected_keypoints = np.array(
+ [[0.1, 0.2], [0.2, 0.4], [0.3, 0.6]], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 200, 200, 3])
+ self.assertAllEqual(distorted_labels_, [1])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllClose(distorted_keypoints_.flatten(),
+ expected_keypoints.flatten())
+
+ def testRandomPadToAspectRatioWithCache(self):
+ preprocess_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRunRandomPadToAspectRatioWithMinMaxPaddedSizeRatios(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map()
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio,
+ {'min_padded_size_ratio': (4.0, 4.0),
+ 'max_padded_size_ratio': (4.0, 4.0)})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ with self.test_session() as sess:
+ distorted_image_, distorted_boxes_, distorted_labels_ = sess.run([
+ distorted_image, distorted_boxes, distorted_labels])
+
+ expected_boxes = np.array(
+ [[0.0, 0.125, 0.1875, 0.5], [0.0625, 0.25, 0.1875, 0.5]],
+ dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 800, 800, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+
+ def testRunRandomPadToAspectRatioWithMasks(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ masks = tf.random_uniform([2, 200, 400], dtype=tf.float32)
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_masks = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_masks_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels, distorted_masks
+ ])
+
+ expected_boxes = np.array(
+ [[0.0, 0.25, 0.375, 1.0], [0.125, 0.5, 0.375, 1.0]], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 400, 400, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllEqual(distorted_masks_.shape, [2, 400, 400])
+
+ def testRunRandomPadToAspectRatioWithKeypoints(self):
+ image = self.createColorfulTestImage()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ keypoints = self.createTestKeypoints()
+
+ tensor_dict = {
+ fields.InputDataFields.image: image,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints
+ }
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_keypoints=True)
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {})]
+
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_image = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_labels = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_classes]
+ distorted_keypoints = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ with self.test_session() as sess:
+ (distorted_image_, distorted_boxes_, distorted_labels_,
+ distorted_keypoints_) = sess.run([
+ distorted_image, distorted_boxes, distorted_labels,
+ distorted_keypoints
+ ])
+
+ expected_boxes = np.array(
+ [[0.0, 0.25, 0.375, 1.0], [0.125, 0.5, 0.375, 1.0]], dtype=np.float32)
+ expected_keypoints = np.array([
+ [[0.05, 0.1], [0.1, 0.2], [0.15, 0.3]],
+ [[0.2, 0.4], [0.25, 0.5], [0.3, 0.6]],
+ ], dtype=np.float32)
+ self.assertAllEqual(distorted_image_.shape, [1, 400, 400, 3])
+ self.assertAllEqual(distorted_labels_, [1, 2])
+ self.assertAllClose(distorted_boxes_.flatten(),
+ expected_boxes.flatten())
+ self.assertAllClose(distorted_keypoints_.flatten(),
+ expected_keypoints.flatten())
+
+ def testRandomPadImageWithCache(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,}), (preprocessor.random_pad_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomPadImage(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_image, {})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_, boxes_, padded_boxes_) = sess.run(
+ [boxes_shape, padded_boxes_shape, images_shape,
+ padded_images_shape, boxes, padded_boxes])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+
+ def testRandomPadImageWithKeypoints(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ keypoints = self.createTestKeypoints()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_keypoints: keypoints,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_image, {})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ padded_keypoints = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_keypoints]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ keypoints_shape = tf.shape(keypoints)
+ padded_keypoints_shape = tf.shape(padded_keypoints)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, keypoints_shape_,
+ padded_keypoints_shape_, images_shape_, padded_images_shape_, boxes_,
+ padded_boxes_, keypoints_, padded_keypoints_) = sess.run(
+ [boxes_shape, padded_boxes_shape, keypoints_shape,
+ padded_keypoints_shape, images_shape, padded_images_shape, boxes,
+ padded_boxes, keypoints, padded_keypoints])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertAllEqual(keypoints_shape_, padded_keypoints_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+ self.assertTrue(np.all((keypoints_[1, :, 0] - keypoints_[0, :, 0]) >= (
+ padded_keypoints_[1, :, 0] - padded_keypoints_[0, :, 0])))
+ self.assertTrue(np.all((keypoints_[1, :, 1] - keypoints_[0, :, 1]) >= (
+ padded_keypoints_[1, :, 1] - padded_keypoints_[0, :, 1])))
+
+ def testRandomAbsolutePadImage(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: tf.cast(images, dtype=tf.float32),
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+
+ height_padding = 10
+ width_padding = 20
+ preprocessing_options = [(preprocessor.random_absolute_pad_image, {
+ 'max_height_padding': height_padding,
+ 'max_width_padding': width_padding})]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ original_shape = tf.shape(images)
+ final_shape = tf.shape(padded_tensor_dict[fields.InputDataFields.image])
+
+ with self.test_session() as sess:
+ _, height, width, _ = sess.run(original_shape)
+ for _ in range(100):
+ output_shape = sess.run(final_shape)
+
+ self.assertTrue(output_shape[1] >= height)
+ self.assertTrue(output_shape[1] < height + height_padding)
+ self.assertTrue(output_shape[2] >= width)
+ self.assertTrue(output_shape[2] < width + width_padding)
+
+ def testRandomCropPadImageWithCache(self):
+ preprocess_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1,}), (preprocessor.random_crop_pad_image, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomCropPadImageWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ })]
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, preprocessing_options)
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_pad_image, {
+ 'random_coef': 1.0
+ })]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_, boxes_, padded_boxes_) = sess.run(
+ [boxes_shape, padded_boxes_shape, images_shape,
+ padded_images_shape, boxes, padded_boxes])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertTrue((images_shape_[1] >= padded_images_shape_[1] * 0.5).all)
+ self.assertTrue((images_shape_[2] >= padded_images_shape_[2] * 0.5).all)
+ self.assertTrue((images_shape_[1] <= padded_images_shape_[1]).all)
+ self.assertTrue((images_shape_[2] <= padded_images_shape_[2]).all)
+ self.assertTrue(np.all((boxes_[:, 2] - boxes_[:, 0]) >= (
+ padded_boxes_[:, 2] - padded_boxes_[:, 0])))
+ self.assertTrue(np.all((boxes_[:, 3] - boxes_[:, 1]) >= (
+ padded_boxes_[:, 3] - padded_boxes_[:, 1])))
+
+ def testRandomCropToAspectRatio(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, [])
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_crop_to_aspect_ratio, {
+ 'aspect_ratio': 2.0
+ })]
+ cropped_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ cropped_images = cropped_tensor_dict[fields.InputDataFields.image]
+ cropped_boxes = cropped_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ cropped_boxes_shape = tf.shape(cropped_boxes)
+ images_shape = tf.shape(images)
+ cropped_images_shape = tf.shape(cropped_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, cropped_boxes_shape_, images_shape_,
+ cropped_images_shape_) = sess.run([
+ boxes_shape, cropped_boxes_shape, images_shape, cropped_images_shape
+ ])
+ self.assertAllEqual(boxes_shape_, cropped_boxes_shape_)
+ self.assertEqual(images_shape_[1], cropped_images_shape_[1] * 2)
+ self.assertEqual(images_shape_[2], cropped_images_shape_[2])
+
+ def testRandomPadToAspectRatio(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ }
+ tensor_dict = preprocessor.preprocess(tensor_dict, [])
+ images = tensor_dict[fields.InputDataFields.image]
+
+ preprocessing_options = [(preprocessor.random_pad_to_aspect_ratio, {
+ 'aspect_ratio': 2.0
+ })]
+ padded_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+
+ padded_images = padded_tensor_dict[fields.InputDataFields.image]
+ padded_boxes = padded_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ boxes_shape = tf.shape(boxes)
+ padded_boxes_shape = tf.shape(padded_boxes)
+ images_shape = tf.shape(images)
+ padded_images_shape = tf.shape(padded_images)
+
+ with self.test_session() as sess:
+ (boxes_shape_, padded_boxes_shape_, images_shape_,
+ padded_images_shape_) = sess.run([
+ boxes_shape, padded_boxes_shape, images_shape, padded_images_shape
+ ])
+ self.assertAllEqual(boxes_shape_, padded_boxes_shape_)
+ self.assertEqual(images_shape_[1], padded_images_shape_[1])
+ self.assertEqual(2 * images_shape_[2], padded_images_shape_[2])
+
+ def testRandomBlackPatchesWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_black_patches, {
+ 'size_to_image_ratio': 0.5
+ }))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomBlackPatches(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_black_patches, {
+ 'size_to_image_ratio': 0.5
+ }))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ blacked_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ blacked_images = blacked_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ blacked_images_shape = tf.shape(blacked_images)
+
+ with self.test_session() as sess:
+ (images_shape_, blacked_images_shape_) = sess.run(
+ [images_shape, blacked_images_shape])
+ self.assertAllEqual(images_shape_, blacked_images_shape_)
+
+ def testRandomJpegQuality(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ encoded_images_shape = tf.shape(encoded_images)
+
+ with self.test_session() as sess:
+ images_shape_out, encoded_images_shape_out = sess.run(
+ [images_shape, encoded_images_shape])
+ self.assertAllEqual(images_shape_out, encoded_images_shape_out)
+
+ def testRandomJpegQualityKeepsStaticChannelShape(self):
+ # Set at least three weeks past the forward compatibility horizon for
+ # tf 1.14 of 2019/11/01.
+ # https://github.com/tensorflow/tensorflow/blob/v1.14.0/tensorflow/python/compat/compat.py#L30
+ if not tf.compat.forward_compatible(year=2019, month=12, day=1):
+ self.skipTest('Skipping test for future functionality.')
+
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_static_channels = images.shape[-1]
+ encoded_images_static_channels = encoded_images.shape[-1]
+ self.assertEqual(images_static_channels, encoded_images_static_channels)
+
+ def testRandomJpegQualityWithCache(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'min_jpeg_quality': 0,
+ 'max_jpeg_quality': 100
+ })]
+ self._testPreprocessorCache(preprocessing_options)
+
+ def testRandomJpegQualityWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_jpeg_quality, {
+ 'random_coef': 1.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ encoded_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ encoded_images_shape = tf.shape(encoded_images)
+
+ with self.test_session() as sess:
+ (images_out, encoded_images_out, images_shape_out,
+ encoded_images_shape_out) = sess.run(
+ [images, encoded_images, images_shape, encoded_images_shape])
+ self.assertAllEqual(images_shape_out, encoded_images_shape_out)
+ self.assertAllEqual(images_out, encoded_images_out)
+
+ def testRandomDownscaleToTargetPixels(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 101
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ downscaled_shape = tf.shape(downscaled_images)
+ expected_shape = [1, 5, 20, 3]
+ with self.test_session() as sess:
+ downscaled_shape_out = sess.run(downscaled_shape)
+ self.assertAllEqual(downscaled_shape_out, expected_shape)
+
+ def testRandomDownscaleToTargetPixelsWithMasks(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 101
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ masks = tf.random_uniform([10, 25, 100])
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_instance_masks: masks
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_instance_masks=True)
+ processed_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ downscaled_masks = processed_tensor_dict[
+ fields.InputDataFields.groundtruth_instance_masks]
+ downscaled_images_shape = tf.shape(downscaled_images)
+ downscaled_masks_shape = tf.shape(downscaled_masks)
+ expected_images_shape = [1, 5, 20, 3]
+ expected_masks_shape = [10, 5, 20]
+ with self.test_session() as sess:
+ downscaled_images_shape_out, downscaled_masks_shape_out = sess.run(
+ [downscaled_images_shape, downscaled_masks_shape])
+ self.assertAllEqual(downscaled_images_shape_out, expected_images_shape)
+ self.assertAllEqual(downscaled_masks_shape_out, expected_masks_shape)
+
+ @parameterized.parameters(
+ {'test_masks': False},
+ {'test_masks': True}
+ )
+ def testRandomDownscaleToTargetPixelsWithCache(self, test_masks):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 100,
+ 'max_target_pixels': 999
+ })]
+ self._testPreprocessorCache(preprocessing_options, test_masks=test_masks)
+
+ def testRandomDownscaleToTargetPixelsWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'random_coef': 1.0,
+ 'min_target_pixels': 10,
+ 'max_target_pixels': 20,
+ })]
+ images = tf.random_uniform([1, 25, 100, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ downscaled_images_shape = tf.shape(downscaled_images)
+
+ with self.test_session() as sess:
+ (images_out, downscaled_images_out, images_shape_out,
+ downscaled_images_shape_out) = sess.run(
+ [images, downscaled_images, images_shape, downscaled_images_shape])
+ self.assertAllEqual(images_shape_out, downscaled_images_shape_out)
+ self.assertAllEqual(images_out, downscaled_images_out)
+
+ def testRandomDownscaleToTargetPixelsIgnoresSmallImages(self):
+ preprocessing_options = [(preprocessor.random_downscale_to_target_pixels, {
+ 'min_target_pixels': 1000,
+ 'max_target_pixels': 1001
+ })]
+ images = tf.random_uniform([1, 10, 10, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ downscaled_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ downscaled_images_shape = tf.shape(downscaled_images)
+ with self.test_session() as sess:
+ (images_out, downscaled_images_out, images_shape_out,
+ downscaled_images_shape_out) = sess.run(
+ [images, downscaled_images, images_shape, downscaled_images_shape])
+ self.assertAllEqual(images_shape_out, downscaled_images_shape_out)
+ self.assertAllEqual(images_out, downscaled_images_out)
+
+ def testRandomPatchGaussianShape(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 1,
+ 'max_patch_size': 200,
+ 'min_gaussian_stddev': 0.0,
+ 'max_gaussian_stddev': 2.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ patched_images_shape = tf.shape(patched_images)
+ self.assertAllEqual(images_shape, patched_images_shape)
+
+ def testRandomPatchGaussianClippedToLowerBound(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 20,
+ 'max_patch_size': 40,
+ 'min_gaussian_stddev': 50,
+ 'max_gaussian_stddev': 100
+ })]
+ images = tf.zeros([1, 5, 4, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ self.assertAllGreaterEqual(patched_images, 0.0)
+
+ def testRandomPatchGaussianClippedToUpperBound(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 20,
+ 'max_patch_size': 40,
+ 'min_gaussian_stddev': 50,
+ 'max_gaussian_stddev': 100
+ })]
+ images = tf.constant(255.0, shape=[1, 5, 4, 3])
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ self.assertAllLessEqual(patched_images, 255.0)
+
+ def testRandomPatchGaussianWithCache(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'min_patch_size': 1,
+ 'max_patch_size': 200,
+ 'min_gaussian_stddev': 0.0,
+ 'max_gaussian_stddev': 2.0
+ })]
+ self._testPreprocessorCache(preprocessing_options)
+
+ def testRandomPatchGaussianWithRandomCoefOne(self):
+ preprocessing_options = [(preprocessor.random_patch_gaussian, {
+ 'random_coef': 1.0
+ })]
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ processed_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ patched_images = processed_tensor_dict[fields.InputDataFields.image]
+ images_shape = tf.shape(images)
+ patched_images_shape = tf.shape(patched_images)
+
+ self.assertAllEqual(images_shape, patched_images_shape)
+ self.assertAllEqual(images, patched_images)
+
+ def testAutoAugmentImage(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.autoaugment_image, {
+ 'policy_name': 'v1'
+ }))
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ tensor_dict = {fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes}
+ autoaugment_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options)
+ augmented_images = autoaugment_tensor_dict[fields.InputDataFields.image]
+ augmented_boxes = autoaugment_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ images_shape = tf.shape(images)
+ boxes_shape = tf.shape(boxes)
+ augmented_images_shape = tf.shape(augmented_images)
+ augmented_boxes_shape = tf.shape(augmented_boxes)
+
+ with self.test_session() as sess:
+ (images_shape_, boxes_shape_,
+ augmented_images_shape_, augmented_boxes_shape_) = sess.run(
+ [images_shape, boxes_shape,
+ augmented_images_shape, augmented_boxes_shape])
+ self.assertAllEqual(images_shape_, augmented_images_shape_)
+ self.assertAllEqual(boxes_shape_, augmented_boxes_shape_)
+
+ def testRandomResizeMethodWithCache(self):
+ preprocess_options = []
+ preprocess_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocess_options.append((preprocessor.random_resize_method, {
+ 'target_size': (75, 150)
+ }))
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=True,
+ test_keypoints=True)
+
+ def testRandomResizeMethod(self):
+ preprocessing_options = []
+ preprocessing_options.append((preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }))
+ preprocessing_options.append((preprocessor.random_resize_method, {
+ 'target_size': (75, 150)
+ }))
+ images = self.createTestImages()
+ tensor_dict = {fields.InputDataFields.image: images}
+ resized_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ resized_images = resized_tensor_dict[fields.InputDataFields.image]
+ resized_images_shape = tf.shape(resized_images)
+ expected_images_shape = tf.constant([1, 75, 150, 3], dtype=tf.int32)
+
+ with self.test_session() as sess:
+ (expected_images_shape_, resized_images_shape_) = sess.run(
+ [expected_images_shape, resized_images_shape])
+ self.assertAllEqual(expected_images_shape_,
+ resized_images_shape_)
+
+ def testResizeImageWithMasks(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ height = 50
+ width = 100
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 50, 100], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeImageWithMasksTensorInputHeightAndWidth(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ height = tf.constant(50, dtype=tf.int32)
+ width = tf.constant(100, dtype=tf.int32)
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 50, 100], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeImageWithNoInstanceMask(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ height = 50
+ width = 100
+ expected_image_shape_list = [[50, 100, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 50, 100], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_image(
+ in_image, in_masks, new_height=height, new_width=width)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangePreservesStaticSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[75, 50, 3], [50, 100, 3], [30, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.random_uniform(in_shape)
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ self.assertAllEqual(out_image.get_shape().as_list(), expected_shape)
+
+ def testResizeToRangeWithDynamicSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[75, 50, 3], [50, 100, 3], [30, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ with self.test_session() as sess:
+ out_image_shape = sess.run(out_image_shape,
+ feed_dict={in_image:
+ np.random.randn(*in_shape)})
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToRangeWithPadToMaxDimensionReturnsCorrectShapes(self):
+ in_shape_list = [[60, 40, 3], [15, 30, 3], [15, 50, 3]]
+ min_dim = 50
+ max_dim = 100
+ expected_shape_list = [[100, 100, 3], [100, 100, 3], [100, 100, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True)
+ self.assertAllEqual(out_image.shape.as_list(), expected_shape)
+ out_image_shape = tf.shape(out_image)
+ with self.test_session() as sess:
+ out_image_shape = sess.run(
+ out_image_shape, feed_dict={in_image: np.random.randn(*in_shape)})
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToRangeWithPadToMaxDimensionReturnsCorrectTensor(self):
+ in_image_np = np.array([[[0, 1, 2]]], np.float32)
+ ex_image_np = np.array(
+ [[[0, 1, 2], [123.68, 116.779, 103.939]],
+ [[123.68, 116.779, 103.939], [123.68, 116.779, 103.939]]], np.float32)
+ min_dim = 1
+ max_dim = 2
+
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ out_image, _ = preprocessor.resize_to_range(
+ in_image,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True,
+ per_channel_pad_value=(123.68, 116.779, 103.939))
+
+ with self.test_session() as sess:
+ out_image_np = sess.run(out_image, feed_dict={in_image: in_image_np})
+ self.assertAllClose(ex_image_np, out_image_np)
+
+ def testResizeToRangeWithMasksPreservesStaticSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 75, 50], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ self.assertAllEqual(out_masks.get_shape().as_list(), expected_mask_shape)
+ self.assertAllEqual(out_image.get_shape().as_list(), expected_image_shape)
+
+ def testResizeToRangeWithMasksAndPadToMaxDimension(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[100, 100, 3], [100, 100, 3]]
+ expected_masks_shape_list = [[15, 100, 100], [10, 100, 100]]
+
+ for (in_image_shape,
+ expected_image_shape, in_masks_shape, expected_mask_shape) in zip(
+ in_image_shape_list, expected_image_shape_list,
+ in_masks_shape_list, expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image,
+ in_masks,
+ min_dimension=min_dim,
+ max_dimension=max_dim,
+ pad_to_max_dimension=True)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangeWithMasksAndDynamicSpatialShape(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 40], [10, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 75, 50], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRangeWithInstanceMasksTensorOfSizeZero(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ min_dim = 50
+ max_dim = 100
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 75, 50], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_range(
+ in_image, in_masks, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToRange4DImageTensor(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_range(image, 500, 600)
+
+ def testResizeToRangeSameMinMax(self):
+ """Tests image resizing, checking output sizes."""
+ in_shape_list = [[312, 312, 3], [299, 299, 3]]
+ min_dim = 320
+ max_dim = 320
+ expected_shape_list = [[320, 320, 3], [320, 320, 3]]
+
+ for in_shape, expected_shape in zip(in_shape_list, expected_shape_list):
+ in_image = tf.random_uniform(in_shape)
+ out_image, _ = preprocessor.resize_to_range(
+ in_image, min_dimension=min_dim, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+
+ with self.test_session() as sess:
+ out_image_shape = sess.run(out_image_shape)
+ self.assertAllEqual(out_image_shape, expected_shape)
+
+ def testResizeToMaxDimensionTensorShapes(self):
+ """Tests both cases where image should and shouldn't be resized."""
+ in_image_shape_list = [[100, 50, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 100, 50], [10, 15, 30]]
+ max_dim = 50
+ expected_image_shape_list = [[50, 25, 3], [15, 30, 3]]
+ expected_masks_shape_list = [[15, 50, 25], [10, 15, 30]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_max_dimension(
+ in_image, in_masks, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMaxDimensionWithInstanceMasksTensorOfSizeZero(self):
+ """Tests both cases where image should and shouldn't be resized."""
+ in_image_shape_list = [[100, 50, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 100, 50], [0, 15, 30]]
+ max_dim = 50
+ expected_image_shape_list = [[50, 25, 3], [15, 30, 3]]
+ expected_masks_shape_list = [[0, 50, 25], [0, 15, 30]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_max_dimension(
+ in_image, in_masks, max_dimension=max_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMaxDimensionRaisesErrorOn4DImage(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_max_dimension(image, 500)
+
+ def testResizeToMinDimensionTensorShapes(self):
+ in_image_shape_list = [[60, 55, 3], [15, 30, 3]]
+ in_masks_shape_list = [[15, 60, 55], [10, 15, 30]]
+ min_dim = 50
+ expected_image_shape_list = [[60, 55, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[15, 60, 55], [10, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.placeholder(tf.float32, shape=(None, None, 3))
+ in_masks = tf.placeholder(tf.float32, shape=(None, None, None))
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_min_dimension(
+ in_image, in_masks, min_dimension=min_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape],
+ feed_dict={
+ in_image: np.random.randn(*in_image_shape),
+ in_masks: np.random.randn(*in_masks_shape)
+ })
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMinDimensionWithInstanceMasksTensorOfSizeZero(self):
+ """Tests image resizing, checking output sizes."""
+ in_image_shape_list = [[60, 40, 3], [15, 30, 3]]
+ in_masks_shape_list = [[0, 60, 40], [0, 15, 30]]
+ min_dim = 50
+ expected_image_shape_list = [[75, 50, 3], [50, 100, 3]]
+ expected_masks_shape_list = [[0, 75, 50], [0, 50, 100]]
+
+ for (in_image_shape, expected_image_shape, in_masks_shape,
+ expected_mask_shape) in zip(in_image_shape_list,
+ expected_image_shape_list,
+ in_masks_shape_list,
+ expected_masks_shape_list):
+ in_image = tf.random_uniform(in_image_shape)
+ in_masks = tf.random_uniform(in_masks_shape)
+ out_image, out_masks, _ = preprocessor.resize_to_min_dimension(
+ in_image, in_masks, min_dimension=min_dim)
+ out_image_shape = tf.shape(out_image)
+ out_masks_shape = tf.shape(out_masks)
+
+ with self.test_session() as sess:
+ out_image_shape, out_masks_shape = sess.run(
+ [out_image_shape, out_masks_shape])
+ self.assertAllEqual(out_image_shape, expected_image_shape)
+ self.assertAllEqual(out_masks_shape, expected_mask_shape)
+
+ def testResizeToMinDimensionRaisesErrorOn4DImage(self):
+ image = tf.random_uniform([1, 200, 300, 3])
+ with self.assertRaises(ValueError):
+ preprocessor.resize_to_min_dimension(image, 500)
+
+ def testScaleBoxesToPixelCoordinates(self):
+ """Tests box scaling, checking scaled values."""
+ in_shape = [60, 40, 3]
+ in_boxes = [[0.1, 0.2, 0.4, 0.6],
+ [0.5, 0.3, 0.9, 0.7]]
+
+ expected_boxes = [[6., 8., 24., 24.],
+ [30., 12., 54., 28.]]
+
+ in_image = tf.random_uniform(in_shape)
+ in_boxes = tf.constant(in_boxes)
+ _, out_boxes = preprocessor.scale_boxes_to_pixel_coordinates(
+ in_image, boxes=in_boxes)
+ with self.test_session() as sess:
+ out_boxes = sess.run(out_boxes)
+ self.assertAllClose(out_boxes, expected_boxes)
+
+ def testScaleBoxesToPixelCoordinatesWithKeypoints(self):
+ """Tests box and keypoint scaling, checking scaled values."""
+ in_shape = [60, 40, 3]
+ in_boxes = self.createTestBoxes()
+ in_keypoints = self.createTestKeypoints()
+
+ expected_boxes = [[0., 10., 45., 40.],
+ [15., 20., 45., 40.]]
+ expected_keypoints = [
+ [[6., 4.], [12., 8.], [18., 12.]],
+ [[24., 16.], [30., 20.], [36., 24.]],
+ ]
+
+ in_image = tf.random_uniform(in_shape)
+ _, out_boxes, out_keypoints = preprocessor.scale_boxes_to_pixel_coordinates(
+ in_image, boxes=in_boxes, keypoints=in_keypoints)
+ with self.test_session() as sess:
+ out_boxes_, out_keypoints_ = sess.run([out_boxes, out_keypoints])
+ self.assertAllClose(out_boxes_, expected_boxes)
+ self.assertAllClose(out_keypoints_, expected_keypoints)
+
+ def testSubtractChannelMean(self):
+ """Tests whether channel means have been subtracted."""
+ with self.test_session():
+ image = tf.zeros((240, 320, 3))
+ means = [1, 2, 3]
+ actual = preprocessor.subtract_channel_mean(image, means=means)
+ actual = actual.eval()
+
+ self.assertTrue((actual[:, :, 0] == -1).all())
+ self.assertTrue((actual[:, :, 1] == -2).all())
+ self.assertTrue((actual[:, :, 2] == -3).all())
+
+ def testOneHotEncoding(self):
+ """Tests one hot encoding of multiclass labels."""
+ with self.test_session():
+ labels = tf.constant([1, 4, 2], dtype=tf.int32)
+ one_hot = preprocessor.one_hot_encoding(labels, num_classes=5)
+ one_hot = one_hot.eval()
+
+ self.assertAllEqual([0, 1, 1, 0, 1], one_hot)
+
+ def testRandomSelfConcatImage(self):
+ tf.set_random_seed(24601)
+
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ confidences = weights
+ scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: tf.cast(images, dtype=tf.float32),
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ fields.InputDataFields.groundtruth_confidences: confidences,
+ fields.InputDataFields.multiclass_scores: scores,
+ }
+
+ preprocessing_options = [(preprocessor.random_self_concat_image, {
+ 'concat_vertical_probability': 0.5,
+ 'concat_horizontal_probability': 0.5,
+ 'seed': 24601,
+ })]
+ func_arg_map = preprocessor.get_default_func_arg_map(
+ True, True, True)
+ output_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=func_arg_map)
+
+ final_shape = tf.shape(output_tensor_dict[fields.InputDataFields.image])[
+ 1:3]
+
+ with self.test_session() as sess:
+ outputs = []
+
+ augment_height_only = False
+ augment_width_only = False
+
+ for _ in range(50):
+ original_boxes = sess.run(boxes)
+ shape, new_boxes, new_labels, new_confidences, new_scores = sess.run(
+ [final_shape,
+ output_tensor_dict[fields.InputDataFields.groundtruth_boxes],
+ output_tensor_dict[fields.InputDataFields.groundtruth_classes],
+ output_tensor_dict[fields.InputDataFields.groundtruth_confidences],
+ output_tensor_dict[fields.InputDataFields.multiclass_scores],
+ ])
+ shape = np.array(shape)
+ outputs.append(shape)
+
+ if np.array_equal(shape, [8, 4]):
+ augment_height_only = True
+ self.assertEqual(
+ new_boxes.shape[0], 2 * boxes.shape[0])
+
+ self.assertAllClose(new_boxes[:2, :] * [2.0, 1.0, 2.0, 1.0],
+ original_boxes)
+ self.assertAllClose(
+ (new_boxes[2:, :] - [0.5, 0.0, 0.5, 0.0]) * [
+ 2.0, 1.0, 2.0, 1.0],
+ original_boxes)
+ elif np.array_equal(shape, [4, 8]):
+ augment_width_only = True
+ self.assertEqual(
+ new_boxes.shape[0], 2 * boxes.shape[0])
+
+ self.assertAllClose(new_boxes[:2, :] * [1.0, 2.0, 1.0, 2.0],
+ original_boxes)
+ self.assertAllClose(
+ (new_boxes[2:, :] - [0.0, 0.5, 0.0, 0.5]) * [
+ 1.0, 2.0, 1.0, 2.0],
+ original_boxes)
+
+ augmentation_factor = new_boxes.shape[0] / boxes.shape[0].value
+ self.assertEqual(new_labels.shape[0],
+ labels.shape[0].value * augmentation_factor)
+ self.assertEqual(new_confidences.shape[0],
+ confidences.shape[0].value * augmentation_factor)
+ self.assertEqual(new_scores.shape[0],
+ scores.shape[0].value * augmentation_factor)
+
+ max_height = max(x[0] for x in outputs)
+ max_width = max(x[1] for x in outputs)
+
+ self.assertEqual(max_height, 8)
+ self.assertEqual(max_width, 8)
+ self.assertEqual(augment_height_only, True)
+ self.assertEqual(augment_width_only, True)
+
+ def testSSDRandomCropWithCache(self):
+ preprocess_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def testSSDRandomCrop(self):
+ preprocessing_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropWithMultiClassScores(self):
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }), (preprocessor.ssd_random_crop, {})]
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ multiclass_scores = self.createTestMultiClassScores()
+
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.multiclass_scores: multiclass_scores,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_multiclass_scores=True)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ distorted_multiclass_scores = distorted_tensor_dict[
+ fields.InputDataFields.multiclass_scores]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+ multiclass_scores_rank = tf.rank(multiclass_scores)
+ distorted_multiclass_scores_rank = tf.rank(distorted_multiclass_scores)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_, multiclass_scores_rank_,
+ distorted_multiclass_scores_,
+ distorted_multiclass_scores_rank_) = sess.run([
+ boxes_rank, distorted_boxes, distorted_boxes_rank, images_rank,
+ distorted_images_rank, multiclass_scores_rank,
+ distorted_multiclass_scores, distorted_multiclass_scores_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+ self.assertAllEqual(multiclass_scores_rank_,
+ distorted_multiclass_scores_rank_)
+ self.assertAllEqual(distorted_boxes_.shape[0],
+ distorted_multiclass_scores_.shape[0])
+
+ def testSSDRandomCropPad(self):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ preprocessing_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop_pad, {})]
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights,
+ }
+ distorted_tensor_dict = preprocessor.preprocess(tensor_dict,
+ preprocessing_options)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run([
+ boxes_rank, distorted_boxes_rank, images_rank, distorted_images_rank
+ ])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropFixedAspectRatioWithCache(self):
+ preprocess_options = [
+ (preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }),
+ (preprocessor.ssd_random_crop_fixed_aspect_ratio, {})]
+ self._testPreprocessorCache(preprocess_options,
+ test_boxes=True,
+ test_masks=False,
+ test_keypoints=False)
+
+ def _testSSDRandomCropFixedAspectRatio(self,
+ include_multiclass_scores,
+ include_instance_masks,
+ include_keypoints):
+ images = self.createTestImages()
+ boxes = self.createTestBoxes()
+ labels = self.createTestLabels()
+ weights = self.createTestGroundtruthWeights()
+ preprocessing_options = [(preprocessor.normalize_image, {
+ 'original_minval': 0,
+ 'original_maxval': 255,
+ 'target_minval': 0,
+ 'target_maxval': 1
+ }), (preprocessor.ssd_random_crop_fixed_aspect_ratio, {})]
+ tensor_dict = {
+ fields.InputDataFields.image: images,
+ fields.InputDataFields.groundtruth_boxes: boxes,
+ fields.InputDataFields.groundtruth_classes: labels,
+ fields.InputDataFields.groundtruth_weights: weights
+ }
+ if include_multiclass_scores:
+ multiclass_scores = self.createTestMultiClassScores()
+ tensor_dict[fields.InputDataFields.multiclass_scores] = (
+ multiclass_scores)
+ if include_instance_masks:
+ masks = self.createTestMasks()
+ tensor_dict[fields.InputDataFields.groundtruth_instance_masks] = masks
+ if include_keypoints:
+ keypoints = self.createTestKeypoints()
+ tensor_dict[fields.InputDataFields.groundtruth_keypoints] = keypoints
+
+ preprocessor_arg_map = preprocessor.get_default_func_arg_map(
+ include_multiclass_scores=include_multiclass_scores,
+ include_instance_masks=include_instance_masks,
+ include_keypoints=include_keypoints)
+ distorted_tensor_dict = preprocessor.preprocess(
+ tensor_dict, preprocessing_options, func_arg_map=preprocessor_arg_map)
+ distorted_images = distorted_tensor_dict[fields.InputDataFields.image]
+ distorted_boxes = distorted_tensor_dict[
+ fields.InputDataFields.groundtruth_boxes]
+ images_rank = tf.rank(images)
+ distorted_images_rank = tf.rank(distorted_images)
+ boxes_rank = tf.rank(boxes)
+ distorted_boxes_rank = tf.rank(distorted_boxes)
+
+ with self.test_session() as sess:
+ (boxes_rank_, distorted_boxes_rank_, images_rank_,
+ distorted_images_rank_) = sess.run(
+ [boxes_rank, distorted_boxes_rank, images_rank,
+ distorted_images_rank])
+ self.assertAllEqual(boxes_rank_, distorted_boxes_rank_)
+ self.assertAllEqual(images_rank_, distorted_images_rank_)
+
+ def testSSDRandomCropFixedAspectRatio(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=False,
+ include_keypoints=False)
+
+ def testSSDRandomCropFixedAspectRatioWithMultiClassScores(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=True,
+ include_instance_masks=False,
+ include_keypoints=False)
+
+ def testSSDRandomCropFixedAspectRatioWithMasksAndKeypoints(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=True,
+ include_keypoints=True)
+
+ def testSSDRandomCropFixedAspectRatioWithLabelScoresMasksAndKeypoints(self):
+ self._testSSDRandomCropFixedAspectRatio(include_multiclass_scores=False,
+ include_instance_masks=True,
+ include_keypoints=True)
+
+ def testConvertClassLogitsToSoftmax(self):
+ multiclass_scores = tf.constant(
+ [[1.0, 0.0], [0.5, 0.5], [1000, 1]], dtype=tf.float32)
+ temperature = 2.0
+
+ converted_multiclass_scores = (
+ preprocessor.convert_class_logits_to_softmax(
+ multiclass_scores=multiclass_scores, temperature=temperature))
+
+ expected_converted_multiclass_scores = [[[0.62245935, 0.37754068],
+ [0.5, 0.5], [1, 0]]]
+
+ with self.test_session() as sess:
+ (converted_multiclass_scores_) = sess.run([converted_multiclass_scores])
+
+ self.assertAllClose(converted_multiclass_scores_,
+ expected_converted_multiclass_scores)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator.py
new file mode 100644
index 00000000..7b6e1485
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator.py
@@ -0,0 +1,159 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Region Similarity Calculators for BoxLists.
+
+Region Similarity Calculators compare a pairwise measure of similarity
+between the boxes in two BoxLists.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from abc import ABCMeta
+from abc import abstractmethod
+
+import six
+import tensorflow as tf
+
+from object_detection.core import box_list_ops
+from object_detection.core import standard_fields as fields
+
+
+class RegionSimilarityCalculator(six.with_metaclass(ABCMeta, object)):
+ """Abstract base class for region similarity calculator."""
+
+ def compare(self, boxlist1, boxlist2, scope=None):
+ """Computes matrix of pairwise similarity between BoxLists.
+
+ This op (to be overridden) computes a measure of pairwise similarity between
+ the boxes in the given BoxLists. Higher values indicate more similarity.
+
+ Note that this method simply measures similarity and does not explicitly
+ perform a matching.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+ scope: Op scope name. Defaults to 'Compare' if None.
+
+ Returns:
+ a (float32) tensor of shape [N, M] with pairwise similarity score.
+ """
+ with tf.name_scope(scope, 'Compare', [boxlist1, boxlist2]) as scope:
+ return self._compare(boxlist1, boxlist2)
+
+ @abstractmethod
+ def _compare(self, boxlist1, boxlist2):
+ pass
+
+
+class IouSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on Intersection over Union (IOU) metric.
+
+ This class computes pairwise similarity between two BoxLists based on IOU.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOU similarity between the two BoxLists.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing pairwise iou scores.
+ """
+ return box_list_ops.iou(boxlist1, boxlist2)
+
+
+class NegSqDistSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on the squared distance metric.
+
+ This class computes pairwise similarity between two BoxLists based on the
+ negative squared distance metric.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute matrix of (negated) sq distances.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing negated pairwise squared distance.
+ """
+ return -1 * box_list_ops.sq_dist(boxlist1, boxlist2)
+
+
+class IoaSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on Intersection over Area (IOA) metric.
+
+ This class computes pairwise similarity between two BoxLists based on their
+ pairwise intersections divided by the areas of second BoxLists.
+ """
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOA similarity between the two BoxLists.
+
+ Args:
+ boxlist1: BoxList holding N boxes.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing pairwise IOA scores.
+ """
+ return box_list_ops.ioa(boxlist1, boxlist2)
+
+
+class ThresholdedIouSimilarity(RegionSimilarityCalculator):
+ """Class to compute similarity based on thresholded IOU and score.
+
+ This class computes pairwise similarity between two BoxLists based on IOU and
+ a 'score' present in boxlist1. If IOU > threshold, then the entry in the
+ output pairwise tensor will contain `score`, otherwise 0.
+ """
+
+ def __init__(self, iou_threshold=0):
+ """Initialize the ThresholdedIouSimilarity.
+
+ Args:
+ iou_threshold: For a given pair of boxes, if the IOU is > iou_threshold,
+ then the comparison result will be the foreground probability of
+ the first box, otherwise it will be zero.
+ """
+ super(ThresholdedIouSimilarity, self).__init__()
+ self._iou_threshold = iou_threshold
+
+ def _compare(self, boxlist1, boxlist2):
+ """Compute pairwise IOU similarity between the two BoxLists and score.
+
+ Args:
+ boxlist1: BoxList holding N boxes. Must have a score field.
+ boxlist2: BoxList holding M boxes.
+
+ Returns:
+ A tensor with shape [N, M] representing scores threholded by pairwise
+ iou scores.
+ """
+ ious = box_list_ops.iou(boxlist1, boxlist2)
+ scores = boxlist1.get_field(fields.BoxListFields.scores)
+ scores = tf.expand_dims(scores, axis=1)
+ row_replicated_scores = tf.tile(scores, [1, tf.shape(ious)[-1]])
+ thresholded_ious = tf.where(ious > self._iou_threshold,
+ row_replicated_scores, tf.zeros_like(ious))
+
+ return thresholded_ious
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator_test.py
new file mode 100644
index 00000000..1d0c26bb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/region_similarity_calculator_test.py
@@ -0,0 +1,95 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for region_similarity_calculator."""
+import tensorflow as tf
+
+from object_detection.core import box_list
+from object_detection.core import region_similarity_calculator
+from object_detection.core import standard_fields as fields
+
+
+class RegionSimilarityCalculatorTest(tf.test.TestCase):
+
+ def test_get_correct_pairwise_similarity_based_on_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output = [[2.0 / 16.0, 0, 6.0 / 400.0], [1.0 / 16.0, 0.0, 5.0 / 400.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ iou_similarity_calculator = region_similarity_calculator.IouSimilarity()
+ iou_similarity = iou_similarity_calculator.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou_similarity)
+ self.assertAllClose(iou_output, exp_output)
+
+ def test_get_correct_pairwise_similarity_based_on_squared_distances(self):
+ corners1 = tf.constant([[0.0, 0.0, 0.0, 0.0],
+ [1.0, 1.0, 0.0, 2.0]])
+ corners2 = tf.constant([[3.0, 4.0, 1.0, 0.0],
+ [-4.0, 0.0, 0.0, 3.0],
+ [0.0, 0.0, 0.0, 0.0]])
+ exp_output = [[-26, -25, 0], [-18, -27, -6]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ dist_similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ dist_similarity = dist_similarity_calc.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ dist_output = sess.run(dist_similarity)
+ self.assertAllClose(dist_output, exp_output)
+
+ def test_get_correct_pairwise_similarity_based_on_ioa(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ exp_output_1 = [[2.0 / 12.0, 0, 6.0 / 400.0],
+ [1.0 / 12.0, 0.0, 5.0 / 400.0]]
+ exp_output_2 = [[2.0 / 6.0, 1.0 / 5.0],
+ [0, 0],
+ [6.0 / 6.0, 5.0 / 5.0]]
+ boxes1 = box_list.BoxList(corners1)
+ boxes2 = box_list.BoxList(corners2)
+ ioa_similarity_calculator = region_similarity_calculator.IoaSimilarity()
+ ioa_similarity_1 = ioa_similarity_calculator.compare(boxes1, boxes2)
+ ioa_similarity_2 = ioa_similarity_calculator.compare(boxes2, boxes1)
+ with self.test_session() as sess:
+ iou_output_1, iou_output_2 = sess.run(
+ [ioa_similarity_1, ioa_similarity_2])
+ self.assertAllClose(iou_output_1, exp_output_1)
+ self.assertAllClose(iou_output_2, exp_output_2)
+
+ def test_get_correct_pairwise_similarity_based_on_thresholded_iou(self):
+ corners1 = tf.constant([[4.0, 3.0, 7.0, 5.0], [5.0, 6.0, 10.0, 7.0]])
+ corners2 = tf.constant([[3.0, 4.0, 6.0, 8.0], [14.0, 14.0, 15.0, 15.0],
+ [0.0, 0.0, 20.0, 20.0]])
+ scores = tf.constant([.3, .6])
+ iou_threshold = .013
+
+ exp_output = tf.constant([[0.3, 0., 0.3], [0.6, 0., 0.]])
+ boxes1 = box_list.BoxList(corners1)
+ boxes1.add_field(fields.BoxListFields.scores, scores)
+ boxes2 = box_list.BoxList(corners2)
+ iou_similarity_calculator = (
+ region_similarity_calculator.ThresholdedIouSimilarity(
+ iou_threshold=iou_threshold))
+ iou_similarity = iou_similarity_calculator.compare(boxes1, boxes2)
+ with self.test_session() as sess:
+ iou_output = sess.run(iou_similarity)
+ self.assertAllClose(iou_output, exp_output)
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/standard_fields.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/standard_fields.py
new file mode 100644
index 00000000..628902eb
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/standard_fields.py
@@ -0,0 +1,263 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Contains classes specifying naming conventions used for object detection.
+
+
+Specifies:
+ InputDataFields: standard fields used by reader/preprocessor/batcher.
+ DetectionResultFields: standard fields returned by object detector.
+ BoxListFields: standard field used by BoxList
+ TfExampleFields: standard fields for tf-example data format (go/tf-example).
+"""
+
+
+class InputDataFields(object):
+ """Names for the input tensors.
+
+ Holds the standard data field names to use for identifying input tensors. This
+ should be used by the decoder to identify keys for the returned tensor_dict
+ containing input tensors. And it should be used by the model to identify the
+ tensors it needs.
+
+ Attributes:
+ image: image.
+ image_additional_channels: additional channels.
+ original_image: image in the original input size.
+ original_image_spatial_shape: image in the original input size.
+ key: unique key corresponding to image.
+ source_id: source of the original image.
+ filename: original filename of the dataset (without common path).
+ groundtruth_image_classes: image-level class labels.
+ groundtruth_image_confidences: image-level class confidences.
+ groundtruth_boxes: coordinates of the ground truth boxes in the image.
+ groundtruth_classes: box-level class labels.
+ groundtruth_confidences: box-level class confidences. The shape should be
+ the same as the shape of groundtruth_classes.
+ groundtruth_label_types: box-level label types (e.g. explicit negative).
+ groundtruth_is_crowd: [DEPRECATED, use groundtruth_group_of instead]
+ is the groundtruth a single object or a crowd.
+ groundtruth_area: area of a groundtruth segment.
+ groundtruth_difficult: is a `difficult` object
+ groundtruth_group_of: is a `group_of` objects, e.g. multiple objects of the
+ same class, forming a connected group, where instances are heavily
+ occluding each other.
+ proposal_boxes: coordinates of object proposal boxes.
+ proposal_objectness: objectness score of each proposal.
+ groundtruth_instance_masks: ground truth instance masks.
+ groundtruth_instance_boundaries: ground truth instance boundaries.
+ groundtruth_instance_classes: instance mask-level class labels.
+ groundtruth_keypoints: ground truth keypoints.
+ groundtruth_keypoint_visibilities: ground truth keypoint visibilities.
+ groundtruth_label_weights: groundtruth label weights.
+ groundtruth_weights: groundtruth weight factor for bounding boxes.
+ num_groundtruth_boxes: number of groundtruth boxes.
+ is_annotated: whether an image has been labeled or not.
+ true_image_shapes: true shapes of images in the resized images, as resized
+ images can be padded with zeros.
+ multiclass_scores: the label score per class for each box.
+ """
+ image = 'image'
+ image_additional_channels = 'image_additional_channels'
+ original_image = 'original_image'
+ original_image_spatial_shape = 'original_image_spatial_shape'
+ key = 'key'
+ source_id = 'source_id'
+ filename = 'filename'
+ groundtruth_image_classes = 'groundtruth_image_classes'
+ groundtruth_image_confidences = 'groundtruth_image_confidences'
+ groundtruth_boxes = 'groundtruth_boxes'
+ groundtruth_classes = 'groundtruth_classes'
+ groundtruth_confidences = 'groundtruth_confidences'
+ groundtruth_label_types = 'groundtruth_label_types'
+ groundtruth_is_crowd = 'groundtruth_is_crowd'
+ groundtruth_area = 'groundtruth_area'
+ groundtruth_difficult = 'groundtruth_difficult'
+ groundtruth_group_of = 'groundtruth_group_of'
+ proposal_boxes = 'proposal_boxes'
+ proposal_objectness = 'proposal_objectness'
+ groundtruth_instance_masks = 'groundtruth_instance_masks'
+ groundtruth_instance_boundaries = 'groundtruth_instance_boundaries'
+ groundtruth_instance_classes = 'groundtruth_instance_classes'
+ groundtruth_keypoints = 'groundtruth_keypoints'
+ groundtruth_keypoint_visibilities = 'groundtruth_keypoint_visibilities'
+ groundtruth_label_weights = 'groundtruth_label_weights'
+ groundtruth_weights = 'groundtruth_weights'
+ num_groundtruth_boxes = 'num_groundtruth_boxes'
+ is_annotated = 'is_annotated'
+ true_image_shape = 'true_image_shape'
+ multiclass_scores = 'multiclass_scores'
+
+
+class DetectionResultFields(object):
+ """Naming conventions for storing the output of the detector.
+
+ Attributes:
+ source_id: source of the original image.
+ key: unique key corresponding to image.
+ detection_boxes: coordinates of the detection boxes in the image.
+ detection_scores: detection scores for the detection boxes in the image.
+ detection_multiclass_scores: class score distribution (including background)
+ for detection boxes in the image including background class.
+ detection_classes: detection-level class labels.
+ detection_masks: contains a segmentation mask for each detection box.
+ detection_boundaries: contains an object boundary for each detection box.
+ detection_keypoints: contains detection keypoints for each detection box.
+ num_detections: number of detections in the batch.
+ raw_detection_boxes: contains decoded detection boxes without Non-Max
+ suppression.
+ raw_detection_scores: contains class score logits for raw detection boxes.
+ detection_anchor_indices: The anchor indices of the detections after NMS.
+ detection_features: contains extracted features for each detected box
+ after NMS.
+ """
+
+ source_id = 'source_id'
+ key = 'key'
+ detection_boxes = 'detection_boxes'
+ detection_scores = 'detection_scores'
+ detection_multiclass_scores = 'detection_multiclass_scores'
+ detection_features = 'detection_features'
+ detection_classes = 'detection_classes'
+ detection_masks = 'detection_masks'
+ detection_boundaries = 'detection_boundaries'
+ detection_keypoints = 'detection_keypoints'
+ num_detections = 'num_detections'
+ raw_detection_boxes = 'raw_detection_boxes'
+ raw_detection_scores = 'raw_detection_scores'
+ detection_anchor_indices = 'detection_anchor_indices'
+
+
+class BoxListFields(object):
+ """Naming conventions for BoxLists.
+
+ Attributes:
+ boxes: bounding box coordinates.
+ classes: classes per bounding box.
+ scores: scores per bounding box.
+ weights: sample weights per bounding box.
+ objectness: objectness score per bounding box.
+ masks: masks per bounding box.
+ boundaries: boundaries per bounding box.
+ keypoints: keypoints per bounding box.
+ keypoint_heatmaps: keypoint heatmaps per bounding box.
+ is_crowd: is_crowd annotation per bounding box.
+ """
+ boxes = 'boxes'
+ classes = 'classes'
+ scores = 'scores'
+ weights = 'weights'
+ confidences = 'confidences'
+ objectness = 'objectness'
+ masks = 'masks'
+ boundaries = 'boundaries'
+ keypoints = 'keypoints'
+ keypoint_heatmaps = 'keypoint_heatmaps'
+ is_crowd = 'is_crowd'
+
+
+class PredictionFields(object):
+ """Naming conventions for standardized prediction outputs.
+
+ Attributes:
+ feature_maps: List of feature maps for prediction.
+ anchors: Generated anchors.
+ raw_detection_boxes: Decoded detection boxes without NMS.
+ raw_detection_feature_map_indices: Feature map indices from which each raw
+ detection box was produced.
+ """
+ feature_maps = 'feature_maps'
+ anchors = 'anchors'
+ raw_detection_boxes = 'raw_detection_boxes'
+ raw_detection_feature_map_indices = 'raw_detection_feature_map_indices'
+
+
+class TfExampleFields(object):
+ """TF-example proto feature names for object detection.
+
+ Holds the standard feature names to load from an Example proto for object
+ detection.
+
+ Attributes:
+ image_encoded: JPEG encoded string
+ image_format: image format, e.g. "JPEG"
+ filename: filename
+ channels: number of channels of image
+ colorspace: colorspace, e.g. "RGB"
+ height: height of image in pixels, e.g. 462
+ width: width of image in pixels, e.g. 581
+ source_id: original source of the image
+ image_class_text: image-level label in text format
+ image_class_label: image-level label in numerical format
+ object_class_text: labels in text format, e.g. ["person", "cat"]
+ object_class_label: labels in numbers, e.g. [16, 8]
+ object_bbox_xmin: xmin coordinates of groundtruth box, e.g. 10, 30
+ object_bbox_xmax: xmax coordinates of groundtruth box, e.g. 50, 40
+ object_bbox_ymin: ymin coordinates of groundtruth box, e.g. 40, 50
+ object_bbox_ymax: ymax coordinates of groundtruth box, e.g. 80, 70
+ object_view: viewpoint of object, e.g. ["frontal", "left"]
+ object_truncated: is object truncated, e.g. [true, false]
+ object_occluded: is object occluded, e.g. [true, false]
+ object_difficult: is object difficult, e.g. [true, false]
+ object_group_of: is object a single object or a group of objects
+ object_depiction: is object a depiction
+ object_is_crowd: [DEPRECATED, use object_group_of instead]
+ is the object a single object or a crowd
+ object_segment_area: the area of the segment.
+ object_weight: a weight factor for the object's bounding box.
+ instance_masks: instance segmentation masks.
+ instance_boundaries: instance boundaries.
+ instance_classes: Classes for each instance segmentation mask.
+ detection_class_label: class label in numbers.
+ detection_bbox_ymin: ymin coordinates of a detection box.
+ detection_bbox_xmin: xmin coordinates of a detection box.
+ detection_bbox_ymax: ymax coordinates of a detection box.
+ detection_bbox_xmax: xmax coordinates of a detection box.
+ detection_score: detection score for the class label and box.
+ """
+ image_encoded = 'image/encoded'
+ image_format = 'image/format' # format is reserved keyword
+ filename = 'image/filename'
+ channels = 'image/channels'
+ colorspace = 'image/colorspace'
+ height = 'image/height'
+ width = 'image/width'
+ source_id = 'image/source_id'
+ image_class_text = 'image/class/text'
+ image_class_label = 'image/class/label'
+ object_class_text = 'image/object/class/text'
+ object_class_label = 'image/object/class/label'
+ object_bbox_ymin = 'image/object/bbox/ymin'
+ object_bbox_xmin = 'image/object/bbox/xmin'
+ object_bbox_ymax = 'image/object/bbox/ymax'
+ object_bbox_xmax = 'image/object/bbox/xmax'
+ object_view = 'image/object/view'
+ object_truncated = 'image/object/truncated'
+ object_occluded = 'image/object/occluded'
+ object_difficult = 'image/object/difficult'
+ object_group_of = 'image/object/group_of'
+ object_depiction = 'image/object/depiction'
+ object_is_crowd = 'image/object/is_crowd'
+ object_segment_area = 'image/object/segment/area'
+ object_weight = 'image/object/weight'
+ instance_masks = 'image/segmentation/object'
+ instance_boundaries = 'image/boundaries/object'
+ instance_classes = 'image/segmentation/object/class'
+ detection_class_label = 'image/detection/label'
+ detection_bbox_ymin = 'image/detection/bbox/ymin'
+ detection_bbox_xmin = 'image/detection/bbox/xmin'
+ detection_bbox_ymax = 'image/detection/bbox/ymax'
+ detection_bbox_xmax = 'image/detection/bbox/xmax'
+ detection_score = 'image/detection/score'
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner.py
new file mode 100644
index 00000000..3e3ba1ae
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner.py
@@ -0,0 +1,707 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Base target assigner module.
+
+The job of a TargetAssigner is, for a given set of anchors (bounding boxes) and
+groundtruth detections (bounding boxes), to assign classification and regression
+targets to each anchor as well as weights to each anchor (specifying, e.g.,
+which anchors should not contribute to training loss).
+
+It assigns classification/regression targets by performing the following steps:
+1) Computing pairwise similarity between anchors and groundtruth boxes using a
+ provided RegionSimilarity Calculator
+2) Computing a matching based on the similarity matrix using a provided Matcher
+3) Assigning regression targets based on the matching and a provided BoxCoder
+4) Assigning classification targets based on the matching and groundtruth labels
+
+Note that TargetAssigners only operate on detections from a single
+image at a time, so any logic for applying a TargetAssigner to multiple
+images must be handled externally.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range
+from six.moves import zip
+import tensorflow as tf
+
+from object_detection.box_coders import faster_rcnn_box_coder
+from object_detection.box_coders import mean_stddev_box_coder
+from object_detection.core import box_coder
+from object_detection.core import box_list
+from object_detection.core import box_list_ops
+from object_detection.core import matcher as mat
+from object_detection.core import region_similarity_calculator as sim_calc
+from object_detection.core import standard_fields as fields
+from object_detection.matchers import argmax_matcher
+from object_detection.matchers import bipartite_matcher
+from object_detection.utils import shape_utils
+
+
+class TargetAssigner(object):
+ """Target assigner to compute classification and regression targets."""
+
+ def __init__(self,
+ similarity_calc,
+ matcher,
+ box_coder_instance,
+ negative_class_weight=1.0):
+ """Construct Object Detection Target Assigner.
+
+ Args:
+ similarity_calc: a RegionSimilarityCalculator
+ matcher: an object_detection.core.Matcher used to match groundtruth to
+ anchors.
+ box_coder_instance: an object_detection.core.BoxCoder used to encode
+ matching groundtruth boxes with respect to anchors.
+ negative_class_weight: classification weight to be associated to negative
+ anchors (default: 1.0). The weight must be in [0., 1.].
+
+ Raises:
+ ValueError: if similarity_calc is not a RegionSimilarityCalculator or
+ if matcher is not a Matcher or if box_coder is not a BoxCoder
+ """
+ if not isinstance(similarity_calc, sim_calc.RegionSimilarityCalculator):
+ raise ValueError('similarity_calc must be a RegionSimilarityCalculator')
+ if not isinstance(matcher, mat.Matcher):
+ raise ValueError('matcher must be a Matcher')
+ if not isinstance(box_coder_instance, box_coder.BoxCoder):
+ raise ValueError('box_coder must be a BoxCoder')
+ self._similarity_calc = similarity_calc
+ self._matcher = matcher
+ self._box_coder = box_coder_instance
+ self._negative_class_weight = negative_class_weight
+
+ @property
+ def box_coder(self):
+ return self._box_coder
+
+ # TODO(rathodv): move labels, scores, and weights to groundtruth_boxes fields.
+ def assign(self,
+ anchors,
+ groundtruth_boxes,
+ groundtruth_labels=None,
+ unmatched_class_label=None,
+ groundtruth_weights=None):
+ """Assign classification and regression targets to each anchor.
+
+ For a given set of anchors and groundtruth detections, match anchors
+ to groundtruth_boxes and assign classification and regression targets to
+ each anchor as well as weights based on the resulting match (specifying,
+ e.g., which anchors should not contribute to training loss).
+
+ Anchors that are not matched to anything are given a classification target
+ of self._unmatched_cls_target which can be specified via the constructor.
+
+ Args:
+ anchors: a BoxList representing N anchors
+ groundtruth_boxes: a BoxList representing M groundtruth boxes
+ groundtruth_labels: a tensor of shape [M, d_1, ... d_k]
+ with labels for each of the ground_truth boxes. The subshape
+ [d_1, ... d_k] can be empty (corresponding to scalar inputs). When set
+ to None, groundtruth_labels assumes a binary problem where all
+ ground_truth boxes get a positive label (of 1).
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ If set to None, unmatched_cls_target is set to be [0] for each anchor.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box. The weights
+ must be in [0., 1.]. If None, all weights are set to 1. Generally no
+ groundtruth boxes with zero weight match to any anchors as matchers are
+ aware of groundtruth weights. Additionally, `cls_weights` and
+ `reg_weights` are calculated using groundtruth weights as an added
+ safety.
+
+ Returns:
+ cls_targets: a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k],
+ where the subshape [d_1, ..., d_k] is compatible with groundtruth_labels
+ which has shape [num_gt_boxes, d_1, d_2, ... d_k].
+ cls_weights: a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k],
+ representing weights for each element in cls_targets.
+ reg_targets: a float32 tensor with shape [num_anchors, box_code_dimension]
+ reg_weights: a float32 tensor with shape [num_anchors]
+ match: an int32 tensor of shape [num_anchors] containing result of anchor
+ groundtruth matching. Each position in the tensor indicates an anchor
+ and holds the following meaning:
+ (1) if match[i] >= 0, anchor i is matched with groundtruth match[i].
+ (2) if match[i]=-1, anchor i is marked to be background .
+ (3) if match[i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if anchors or groundtruth_boxes are not of type
+ box_list.BoxList
+ """
+ if not isinstance(anchors, box_list.BoxList):
+ raise ValueError('anchors must be an BoxList')
+ if not isinstance(groundtruth_boxes, box_list.BoxList):
+ raise ValueError('groundtruth_boxes must be an BoxList')
+
+ if unmatched_class_label is None:
+ unmatched_class_label = tf.constant([0], tf.float32)
+
+ if groundtruth_labels is None:
+ groundtruth_labels = tf.ones(tf.expand_dims(groundtruth_boxes.num_boxes(),
+ 0))
+ groundtruth_labels = tf.expand_dims(groundtruth_labels, -1)
+
+ unmatched_shape_assert = shape_utils.assert_shape_equal(
+ shape_utils.combined_static_and_dynamic_shape(groundtruth_labels)[1:],
+ shape_utils.combined_static_and_dynamic_shape(unmatched_class_label))
+ labels_and_box_shapes_assert = shape_utils.assert_shape_equal(
+ shape_utils.combined_static_and_dynamic_shape(
+ groundtruth_labels)[:1],
+ shape_utils.combined_static_and_dynamic_shape(
+ groundtruth_boxes.get())[:1])
+
+ if groundtruth_weights is None:
+ num_gt_boxes = groundtruth_boxes.num_boxes_static()
+ if not num_gt_boxes:
+ num_gt_boxes = groundtruth_boxes.num_boxes()
+ groundtruth_weights = tf.ones([num_gt_boxes], dtype=tf.float32)
+
+ # set scores on the gt boxes
+ scores = 1 - groundtruth_labels[:, 0]
+ groundtruth_boxes.add_field(fields.BoxListFields.scores, scores)
+
+ with tf.control_dependencies(
+ [unmatched_shape_assert, labels_and_box_shapes_assert]):
+ match_quality_matrix = self._similarity_calc.compare(groundtruth_boxes,
+ anchors)
+ match = self._matcher.match(match_quality_matrix,
+ valid_rows=tf.greater(groundtruth_weights, 0))
+ reg_targets = self._create_regression_targets(anchors,
+ groundtruth_boxes,
+ match)
+ cls_targets = self._create_classification_targets(groundtruth_labels,
+ unmatched_class_label,
+ match)
+ reg_weights = self._create_regression_weights(match, groundtruth_weights)
+
+ cls_weights = self._create_classification_weights(match,
+ groundtruth_weights)
+ # convert cls_weights from per-anchor to per-class.
+ class_label_shape = tf.shape(cls_targets)[1:]
+ weights_shape = tf.shape(cls_weights)
+ weights_multiple = tf.concat(
+ [tf.ones_like(weights_shape), class_label_shape],
+ axis=0)
+ for _ in range(len(cls_targets.get_shape()[1:])):
+ cls_weights = tf.expand_dims(cls_weights, -1)
+ cls_weights = tf.tile(cls_weights, weights_multiple)
+
+ num_anchors = anchors.num_boxes_static()
+ if num_anchors is not None:
+ reg_targets = self._reset_target_shape(reg_targets, num_anchors)
+ cls_targets = self._reset_target_shape(cls_targets, num_anchors)
+ reg_weights = self._reset_target_shape(reg_weights, num_anchors)
+ cls_weights = self._reset_target_shape(cls_weights, num_anchors)
+
+ return (cls_targets, cls_weights, reg_targets, reg_weights,
+ match.match_results)
+
+ def _reset_target_shape(self, target, num_anchors):
+ """Sets the static shape of the target.
+
+ Args:
+ target: the target tensor. Its first dimension will be overwritten.
+ num_anchors: the number of anchors, which is used to override the target's
+ first dimension.
+
+ Returns:
+ A tensor with the shape info filled in.
+ """
+ target_shape = target.get_shape().as_list()
+ target_shape[0] = num_anchors
+ target.set_shape(target_shape)
+ return target
+
+ def _create_regression_targets(self, anchors, groundtruth_boxes, match):
+ """Returns a regression target for each anchor.
+
+ Args:
+ anchors: a BoxList representing N anchors
+ groundtruth_boxes: a BoxList representing M groundtruth_boxes
+ match: a matcher.Match object
+
+ Returns:
+ reg_targets: a float32 tensor with shape [N, box_code_dimension]
+ """
+ matched_gt_boxes = match.gather_based_on_match(
+ groundtruth_boxes.get(),
+ unmatched_value=tf.zeros(4),
+ ignored_value=tf.zeros(4))
+ matched_gt_boxlist = box_list.BoxList(matched_gt_boxes)
+ if groundtruth_boxes.has_field(fields.BoxListFields.keypoints):
+ groundtruth_keypoints = groundtruth_boxes.get_field(
+ fields.BoxListFields.keypoints)
+ matched_keypoints = match.gather_based_on_match(
+ groundtruth_keypoints,
+ unmatched_value=tf.zeros(groundtruth_keypoints.get_shape()[1:]),
+ ignored_value=tf.zeros(groundtruth_keypoints.get_shape()[1:]))
+ matched_gt_boxlist.add_field(fields.BoxListFields.keypoints,
+ matched_keypoints)
+ matched_reg_targets = self._box_coder.encode(matched_gt_boxlist, anchors)
+ match_results_shape = shape_utils.combined_static_and_dynamic_shape(
+ match.match_results)
+
+ # Zero out the unmatched and ignored regression targets.
+ unmatched_ignored_reg_targets = tf.tile(
+ self._default_regression_target(), [match_results_shape[0], 1])
+ matched_anchors_mask = match.matched_column_indicator()
+ reg_targets = tf.where(matched_anchors_mask,
+ matched_reg_targets,
+ unmatched_ignored_reg_targets)
+ return reg_targets
+
+ def _default_regression_target(self):
+ """Returns the default target for anchors to regress to.
+
+ Default regression targets are set to zero (though in
+ this implementation what these targets are set to should
+ not matter as the regression weight of any box set to
+ regress to the default target is zero).
+
+ Returns:
+ default_target: a float32 tensor with shape [1, box_code_dimension]
+ """
+ return tf.constant([self._box_coder.code_size*[0]], tf.float32)
+
+ def _create_classification_targets(self, groundtruth_labels,
+ unmatched_class_label, match):
+ """Create classification targets for each anchor.
+
+ Assign a classification target of for each anchor to the matching
+ groundtruth label that is provided by match. Anchors that are not matched
+ to anything are given the target self._unmatched_cls_target
+
+ Args:
+ groundtruth_labels: a tensor of shape [num_gt_boxes, d_1, ... d_k]
+ with labels for each of the ground_truth boxes. The subshape
+ [d_1, ... d_k] can be empty (corresponding to scalar labels).
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+
+ Returns:
+ a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k], where the
+ subshape [d_1, ..., d_k] is compatible with groundtruth_labels which has
+ shape [num_gt_boxes, d_1, d_2, ... d_k].
+ """
+ return match.gather_based_on_match(
+ groundtruth_labels,
+ unmatched_value=unmatched_class_label,
+ ignored_value=unmatched_class_label)
+
+ def _create_regression_weights(self, match, groundtruth_weights):
+ """Set regression weight for each anchor.
+
+ Only positive anchors are set to contribute to the regression loss, so this
+ method returns a weight of 1 for every positive anchor and 0 for every
+ negative anchor.
+
+ Args:
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box.
+
+ Returns:
+ a float32 tensor with shape [num_anchors] representing regression weights.
+ """
+ return match.gather_based_on_match(
+ groundtruth_weights, ignored_value=0., unmatched_value=0.)
+
+ def _create_classification_weights(self,
+ match,
+ groundtruth_weights):
+ """Create classification weights for each anchor.
+
+ Positive (matched) anchors are associated with a weight of
+ positive_class_weight and negative (unmatched) anchors are associated with
+ a weight of negative_class_weight. When anchors are ignored, weights are set
+ to zero. By default, both positive/negative weights are set to 1.0,
+ but they can be adjusted to handle class imbalance (which is almost always
+ the case in object detection).
+
+ Args:
+ match: a matcher.Match object that provides a matching between anchors
+ and groundtruth boxes.
+ groundtruth_weights: a float tensor of shape [M] indicating the weight to
+ assign to all anchors match to a particular groundtruth box.
+
+ Returns:
+ a float32 tensor with shape [num_anchors] representing classification
+ weights.
+ """
+ return match.gather_based_on_match(
+ groundtruth_weights,
+ ignored_value=0.,
+ unmatched_value=self._negative_class_weight)
+
+ def get_box_coder(self):
+ """Get BoxCoder of this TargetAssigner.
+
+ Returns:
+ BoxCoder object.
+ """
+ return self._box_coder
+
+
+# TODO(rathodv): This method pulls in all the implementation dependencies into
+# core. Therefore its best to have this factory method outside of core.
+def create_target_assigner(reference, stage=None,
+ negative_class_weight=1.0, use_matmul_gather=False):
+ """Factory function for creating standard target assigners.
+
+ Args:
+ reference: string referencing the type of TargetAssigner.
+ stage: string denoting stage: {proposal, detection}.
+ negative_class_weight: classification weight to be associated to negative
+ anchors (default: 1.0)
+ use_matmul_gather: whether to use matrix multiplication based gather which
+ are better suited for TPUs.
+
+ Returns:
+ TargetAssigner: desired target assigner.
+
+ Raises:
+ ValueError: if combination reference+stage is invalid.
+ """
+ if reference == 'Multibox' and stage == 'proposal':
+ similarity_calc = sim_calc.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder_instance = mean_stddev_box_coder.MeanStddevBoxCoder()
+
+ elif reference == 'FasterRCNN' and stage == 'proposal':
+ similarity_calc = sim_calc.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.7,
+ unmatched_threshold=0.3,
+ force_match_for_each_row=True,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder(
+ scale_factors=[10.0, 10.0, 5.0, 5.0])
+
+ elif reference == 'FasterRCNN' and stage == 'detection':
+ similarity_calc = sim_calc.IouSimilarity()
+ # Uses all proposals with IOU < 0.5 as candidate negatives.
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ negatives_lower_than_unmatched=True,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder(
+ scale_factors=[10.0, 10.0, 5.0, 5.0])
+
+ elif reference == 'FastRCNN':
+ similarity_calc = sim_calc.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.1,
+ force_match_for_each_row=False,
+ negatives_lower_than_unmatched=False,
+ use_matmul_gather=use_matmul_gather)
+ box_coder_instance = faster_rcnn_box_coder.FasterRcnnBoxCoder()
+
+ else:
+ raise ValueError('No valid combination of reference and stage.')
+
+ return TargetAssigner(similarity_calc, matcher, box_coder_instance,
+ negative_class_weight=negative_class_weight)
+
+
+def batch_assign(target_assigner,
+ anchors_batch,
+ gt_box_batch,
+ gt_class_targets_batch,
+ unmatched_class_label=None,
+ gt_weights_batch=None):
+ """Batched assignment of classification and regression targets.
+
+ Args:
+ target_assigner: a target assigner.
+ anchors_batch: BoxList representing N box anchors or list of BoxList objects
+ with length batch_size representing anchor sets.
+ gt_box_batch: a list of BoxList objects with length batch_size
+ representing groundtruth boxes for each image in the batch
+ gt_class_targets_batch: a list of tensors with length batch_size, where
+ each tensor has shape [num_gt_boxes_i, classification_target_size] and
+ num_gt_boxes_i is the number of boxes in the ith boxlist of
+ gt_box_batch.
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ gt_weights_batch: A list of 1-D tf.float32 tensors of shape
+ [num_boxes] containing weights for groundtruth boxes.
+
+ Returns:
+ batch_cls_targets: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_cls_weights: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_reg_targets: a tensor with shape [batch_size, num_anchors,
+ box_code_dimension]
+ batch_reg_weights: a tensor with shape [batch_size, num_anchors],
+ match: an int32 tensor of shape [batch_size, num_anchors] containing result
+ of anchor groundtruth matching. Each position in the tensor indicates an
+ anchor and holds the following meaning:
+ (1) if match[x, i] >= 0, anchor i is matched with groundtruth match[x, i].
+ (2) if match[x, i]=-1, anchor i is marked to be background .
+ (3) if match[x, i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if input list lengths are inconsistent, i.e.,
+ batch_size == len(gt_box_batch) == len(gt_class_targets_batch)
+ and batch_size == len(anchors_batch) unless anchors_batch is a single
+ BoxList.
+ """
+ if not isinstance(anchors_batch, list):
+ anchors_batch = len(gt_box_batch) * [anchors_batch]
+ if not all(
+ isinstance(anchors, box_list.BoxList) for anchors in anchors_batch):
+ raise ValueError('anchors_batch must be a BoxList or list of BoxLists.')
+ if not (len(anchors_batch)
+ == len(gt_box_batch)
+ == len(gt_class_targets_batch)):
+ raise ValueError('batch size incompatible with lengths of anchors_batch, '
+ 'gt_box_batch and gt_class_targets_batch.')
+ cls_targets_list = []
+ cls_weights_list = []
+ reg_targets_list = []
+ reg_weights_list = []
+ match_list = []
+ if gt_weights_batch is None:
+ gt_weights_batch = [None] * len(gt_class_targets_batch)
+ for anchors, gt_boxes, gt_class_targets, gt_weights in zip(
+ anchors_batch, gt_box_batch, gt_class_targets_batch, gt_weights_batch):
+ (cls_targets, cls_weights,
+ reg_targets, reg_weights, match) = target_assigner.assign(
+ anchors, gt_boxes, gt_class_targets, unmatched_class_label, gt_weights)
+ cls_targets_list.append(cls_targets)
+ cls_weights_list.append(cls_weights)
+ reg_targets_list.append(reg_targets)
+ reg_weights_list.append(reg_weights)
+ match_list.append(match)
+ batch_cls_targets = tf.stack(cls_targets_list)
+ batch_cls_weights = tf.stack(cls_weights_list)
+ batch_reg_targets = tf.stack(reg_targets_list)
+ batch_reg_weights = tf.stack(reg_weights_list)
+ batch_match = tf.stack(match_list)
+ return (batch_cls_targets, batch_cls_weights, batch_reg_targets,
+ batch_reg_weights, batch_match)
+
+
+# Assign an alias to avoid large refactor of existing users.
+batch_assign_targets = batch_assign
+
+
+def batch_get_targets(batch_match, groundtruth_tensor_list,
+ groundtruth_weights_list, unmatched_value,
+ unmatched_weight):
+ """Returns targets based on anchor-groundtruth box matching results.
+
+ Args:
+ batch_match: An int32 tensor of shape [batch, num_anchors] containing the
+ result of target assignment returned by TargetAssigner.assign(..).
+ groundtruth_tensor_list: A list of groundtruth tensors of shape
+ [num_groundtruth, d_1, d_2, ..., d_k]. The tensors can be of any type.
+ groundtruth_weights_list: A list of weights, one per groundtruth tensor, of
+ shape [num_groundtruth].
+ unmatched_value: A tensor of shape [d_1, d_2, ..., d_k] of the same type as
+ groundtruth tensor containing target value for anchors that remain
+ unmatched.
+ unmatched_weight: Scalar weight to assign to anchors that remain unmatched.
+
+ Returns:
+ targets: A tensor of shape [batch, num_anchors, d_1, d_2, ..., d_k]
+ containing targets for anchors.
+ weights: A float tensor of shape [batch, num_anchors] containing the weights
+ to assign to each target.
+ """
+ match_list = tf.unstack(batch_match)
+ targets_list = []
+ weights_list = []
+ for match_tensor, groundtruth_tensor, groundtruth_weight in zip(
+ match_list, groundtruth_tensor_list, groundtruth_weights_list):
+ match_object = mat.Match(match_tensor)
+ targets = match_object.gather_based_on_match(
+ groundtruth_tensor,
+ unmatched_value=unmatched_value,
+ ignored_value=unmatched_value)
+ targets_list.append(targets)
+ weights = match_object.gather_based_on_match(
+ groundtruth_weight,
+ unmatched_value=unmatched_weight,
+ ignored_value=tf.zeros_like(unmatched_weight))
+ weights_list.append(weights)
+ return tf.stack(targets_list), tf.stack(weights_list)
+
+
+def batch_assign_confidences(target_assigner,
+ anchors_batch,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ gt_weights_batch=None,
+ unmatched_class_label=None,
+ include_background_class=True,
+ implicit_class_weight=1.0):
+ """Batched assignment of classification and regression targets.
+
+ This differences between batch_assign_confidences and batch_assign_targets:
+ - 'batch_assign_targets' supports scalar (agnostic), vector (multiclass) and
+ tensor (high-dimensional) targets. 'batch_assign_confidences' only support
+ scalar (agnostic) and vector (multiclass) targets.
+ - 'batch_assign_targets' assumes the input class tensor using the binary
+ one/K-hot encoding. 'batch_assign_confidences' takes the class confidence
+ scores as the input, where 1 means positive classes, 0 means implicit
+ negative classes, and -1 means explicit negative classes.
+ - 'batch_assign_confidences' assigns the targets in the similar way as
+ 'batch_assign_targets' except that it gives different weights for implicit
+ and explicit classes. This allows user to control the negative gradients
+ pushed differently for implicit and explicit examples during the training.
+
+ Args:
+ target_assigner: a target assigner.
+ anchors_batch: BoxList representing N box anchors or list of BoxList objects
+ with length batch_size representing anchor sets.
+ gt_box_batch: a list of BoxList objects with length batch_size
+ representing groundtruth boxes for each image in the batch
+ gt_class_confidences_batch: a list of tensors with length batch_size, where
+ each tensor has shape [num_gt_boxes_i, classification_target_size] and
+ num_gt_boxes_i is the number of boxes in the ith boxlist of
+ gt_box_batch. Note that in this tensor, 1 means explicit positive class,
+ -1 means explicit negative class, and 0 means implicit negative class.
+ gt_weights_batch: A list of 1-D tf.float32 tensors of shape
+ [num_gt_boxes_i] containing weights for groundtruth boxes.
+ unmatched_class_label: a float32 tensor with shape [d_1, d_2, ..., d_k]
+ which is consistent with the classification target for each
+ anchor (and can be empty for scalar targets). This shape must thus be
+ compatible with the groundtruth labels that are passed to the "assign"
+ function (which have shape [num_gt_boxes, d_1, d_2, ..., d_k]).
+ include_background_class: whether or not gt_class_confidences_batch includes
+ the background class.
+ implicit_class_weight: the weight assigned to implicit examples.
+
+ Returns:
+ batch_cls_targets: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_cls_weights: a tensor with shape [batch_size, num_anchors,
+ num_classes],
+ batch_reg_targets: a tensor with shape [batch_size, num_anchors,
+ box_code_dimension]
+ batch_reg_weights: a tensor with shape [batch_size, num_anchors],
+ match: an int32 tensor of shape [batch_size, num_anchors] containing result
+ of anchor groundtruth matching. Each position in the tensor indicates an
+ anchor and holds the following meaning:
+ (1) if match[x, i] >= 0, anchor i is matched with groundtruth match[x, i].
+ (2) if match[x, i]=-1, anchor i is marked to be background .
+ (3) if match[x, i]=-2, anchor i is ignored since it is not background and
+ does not have sufficient overlap to call it a foreground.
+
+ Raises:
+ ValueError: if input list lengths are inconsistent, i.e.,
+ batch_size == len(gt_box_batch) == len(gt_class_targets_batch)
+ and batch_size == len(anchors_batch) unless anchors_batch is a single
+ BoxList, or if any element in gt_class_confidences_batch has rank > 2.
+ """
+ if not isinstance(anchors_batch, list):
+ anchors_batch = len(gt_box_batch) * [anchors_batch]
+ if not all(
+ isinstance(anchors, box_list.BoxList) for anchors in anchors_batch):
+ raise ValueError('anchors_batch must be a BoxList or list of BoxLists.')
+ if not (len(anchors_batch)
+ == len(gt_box_batch)
+ == len(gt_class_confidences_batch)):
+ raise ValueError('batch size incompatible with lengths of anchors_batch, '
+ 'gt_box_batch and gt_class_confidences_batch.')
+
+ cls_targets_list = []
+ cls_weights_list = []
+ reg_targets_list = []
+ reg_weights_list = []
+ match_list = []
+ if gt_weights_batch is None:
+ gt_weights_batch = [None] * len(gt_class_confidences_batch)
+ for anchors, gt_boxes, gt_class_confidences, gt_weights in zip(
+ anchors_batch, gt_box_batch, gt_class_confidences_batch,
+ gt_weights_batch):
+
+ if (gt_class_confidences is not None and
+ len(gt_class_confidences.get_shape().as_list()) > 2):
+ raise ValueError('The shape of the class target is not supported. ',
+ gt_class_confidences.get_shape())
+
+ cls_targets, _, reg_targets, _, match = target_assigner.assign(
+ anchors, gt_boxes, gt_class_confidences, unmatched_class_label,
+ groundtruth_weights=gt_weights)
+
+ if include_background_class:
+ cls_targets_without_background = tf.slice(
+ cls_targets, [0, 1], [-1, -1])
+ else:
+ cls_targets_without_background = cls_targets
+
+ positive_mask = tf.greater(cls_targets_without_background, 0.0)
+ negative_mask = tf.less(cls_targets_without_background, 0.0)
+ explicit_example_mask = tf.logical_or(positive_mask, negative_mask)
+ positive_anchors = tf.reduce_any(positive_mask, axis=-1)
+
+ regression_weights = tf.cast(positive_anchors, dtype=tf.float32)
+ regression_targets = (
+ reg_targets * tf.expand_dims(regression_weights, axis=-1))
+ regression_weights_expanded = tf.expand_dims(regression_weights, axis=-1)
+
+ cls_targets_without_background = (
+ cls_targets_without_background *
+ (1 - tf.cast(negative_mask, dtype=tf.float32)))
+ cls_weights_without_background = ((1 - implicit_class_weight) * tf.cast(
+ explicit_example_mask, dtype=tf.float32) + implicit_class_weight)
+
+ if include_background_class:
+ cls_weights_background = (
+ (1 - implicit_class_weight) * regression_weights_expanded
+ + implicit_class_weight)
+ classification_weights = tf.concat(
+ [cls_weights_background, cls_weights_without_background], axis=-1)
+ cls_targets_background = 1 - regression_weights_expanded
+ classification_targets = tf.concat(
+ [cls_targets_background, cls_targets_without_background], axis=-1)
+ else:
+ classification_targets = cls_targets_without_background
+ classification_weights = cls_weights_without_background
+
+ cls_targets_list.append(classification_targets)
+ cls_weights_list.append(classification_weights)
+ reg_targets_list.append(regression_targets)
+ reg_weights_list.append(regression_weights)
+ match_list.append(match)
+ batch_cls_targets = tf.stack(cls_targets_list)
+ batch_cls_weights = tf.stack(cls_weights_list)
+ batch_reg_targets = tf.stack(reg_targets_list)
+ batch_reg_weights = tf.stack(reg_weights_list)
+ batch_match = tf.stack(match_list)
+ return (batch_cls_targets, batch_cls_weights, batch_reg_targets,
+ batch_reg_weights, batch_match)
+
+
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner_test.py b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner_test.py
new file mode 100644
index 00000000..1ac67f2b
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/core/target_assigner_test.py
@@ -0,0 +1,1232 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for object_detection.core.target_assigner."""
+import numpy as np
+import tensorflow as tf
+
+from object_detection.box_coders import keypoint_box_coder
+from object_detection.box_coders import mean_stddev_box_coder
+from object_detection.core import box_list
+from object_detection.core import region_similarity_calculator
+from object_detection.core import standard_fields as fields
+from object_detection.core import target_assigner as targetassigner
+from object_detection.matchers import argmax_matcher
+from object_detection.matchers import bipartite_matcher
+from object_detection.utils import test_case
+
+
+class TargetAssignerTest(test_case.TestCase):
+
+ def test_assign_agnostic(self):
+ def graph_fn(anchor_means, groundtruth_box_corners):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_class_agnostic_with_ignored_matches(self):
+ # Note: test is very similar to above. The third box matched with an IOU
+ # of 0.35, which is between the matched and unmatched threshold. This means
+ # That like above the expected classification targets are [1, 1, 0].
+ # Unlike above, the third target is ignored and therefore expected
+ # classification weights are [1, 1, 0].
+ def graph_fn(anchor_means, groundtruth_box_corners):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.3)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9]], dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [0]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_agnostic_with_keypoints(self):
+ def graph_fn(anchor_means, groundtruth_box_corners,
+ groundtruth_keypoints):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = keypoint_box_coder.KeypointBoxCoder(
+ num_keypoints=6, scale_factors=[10.0, 10.0, 5.0, 5.0])
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ groundtruth_boxlist.add_field(fields.BoxListFields.keypoints,
+ groundtruth_keypoints)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 1.0],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.45, 0.45, 0.95, 0.95]],
+ dtype=np.float32)
+ groundtruth_keypoints = np.array(
+ [[[0.1, 0.2], [0.1, 0.3], [0.2, 0.2], [0.2, 0.2], [0.1, 0.1], [0.9, 0]],
+ [[0, 0.3], [0.2, 0.4], [0.5, 0.6], [0, 0.6], [0.8, 0.2], [0.2, 0.4]]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0, -3, -1, -3, 1, -1, -1, -1, -1, -3, -3, 13,
+ -5],
+ [-1, -1, 0, 0, -15, -9, -11, -7, -5, -3, -15, -3, 1, -11,
+ -11, -7],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [anchor_means,
+ groundtruth_box_corners,
+ groundtruth_keypoints])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_class_agnostic_with_keypoints_and_ignored_matches(self):
+ # Note: test is very similar to above. The third box matched with an IOU
+ # of 0.35, which is between the matched and unmatched threshold. This means
+ # That like above the expected classification targets are [1, 1, 0].
+ # Unlike above, the third target is ignored and therefore expected
+ # classification weights are [1, 1, 0].
+ def graph_fn(anchor_means, groundtruth_box_corners,
+ groundtruth_keypoints):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = keypoint_box_coder.KeypointBoxCoder(
+ num_keypoints=6, scale_factors=[10.0, 10.0, 5.0, 5.0])
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ groundtruth_boxlist.add_field(fields.BoxListFields.keypoints,
+ groundtruth_keypoints)
+ result = target_assigner.assign(
+ anchors_boxlist, groundtruth_boxlist, unmatched_class_label=None)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 1.0],
+ [0.0, 0.5, .9, 1.0]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.45, 0.45, 0.95, 0.95]],
+ dtype=np.float32)
+ groundtruth_keypoints = np.array(
+ [[[0.1, 0.2], [0.1, 0.3], [0.2, 0.2], [0.2, 0.2], [0.1, 0.1], [0.9, 0]],
+ [[0, 0.3], [0.2, 0.4], [0.5, 0.6], [0, 0.6], [0.8, 0.2], [0.2, 0.4]]],
+ dtype=np.float32)
+ exp_cls_targets = [[1], [1], [0]]
+ exp_cls_weights = [[1], [1], [1]]
+ exp_reg_targets = [[0, 0, 0, 0, -3, -1, -3, 1, -1, -1, -1, -1, -3, -3, 13,
+ -5],
+ [-1, -1, 0, 0, -15, -9, -11, -7, -5, -3, -15, -3, 1, -11,
+ -11, -7],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+ exp_reg_weights = [1, 1, 0]
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [anchor_means,
+ groundtruth_box_corners,
+ groundtruth_keypoints])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_multiclass(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+ groundtruth_labels = np.array([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], dtype=np.float32)
+
+ exp_cls_targets = [[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [1, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 1, 0, 0, 0]]
+ exp_cls_weights = [[1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0],
+ [0, 0, -.5, .2]]
+ exp_reg_weights = [1, 1, 0, 1]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_multiclass_with_groundtruth_weights(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels,
+ groundtruth_weights):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label,
+ groundtruth_weights=groundtruth_weights)
+ (_, cls_weights, _, reg_weights, _) = result
+ return (cls_weights, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+ groundtruth_labels = np.array([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], dtype=np.float32)
+ groundtruth_weights = np.array([0.3, 0., 0.5], dtype=np.float32)
+
+ # background class gets weight of 1.
+ exp_cls_weights = [[0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3],
+ [0, 0, 0, 0, 0, 0, 0],
+ [1, 1, 1, 1, 1, 1, 1],
+ [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]]
+ exp_reg_weights = [0.3, 0., 0., 0.5] # background class gets weight of 0.
+
+ (cls_weights_out, reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_box_corners, groundtruth_labels,
+ groundtruth_weights
+ ])
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_assign_multidimensional_class_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+
+ unmatched_class_label = tf.constant([[0, 0], [0, 0]], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]], dtype=np.float32)
+ groundtruth_box_corners = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]], dtype=np.float32)
+
+ groundtruth_labels = np.array([[[0, 1], [1, 0]],
+ [[1, 0], [0, 1]],
+ [[0, 1], [1, .5]]], np.float32)
+
+ exp_cls_targets = [[[0, 1], [1, 0]],
+ [[1, 0], [0, 1]],
+ [[0, 0], [0, 0]],
+ [[0, 1], [1, .5]]]
+ exp_cls_weights = [[[1, 1], [1, 1]],
+ [[1, 1], [1, 1]],
+ [[1, 1], [1, 1]],
+ [[1, 1], [1, 1]]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, -1, 1],
+ [0, 0, 0, 0],
+ [0, 0, -.5, .2]]
+ exp_reg_weights = [1, 1, 0, 1]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, groundtruth_labels):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ unmatched_class_label = tf.constant([0, 0, 0], tf.float32)
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+ result = target_assigner.assign(
+ anchors_boxlist,
+ groundtruth_boxlist,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+ (cls_targets, cls_weights, reg_targets, reg_weights, _) = result
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ groundtruth_labels = np.zeros((0, 3), dtype=np.float32)
+ anchor_means = np.array([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]],
+ dtype=np.float32)
+ exp_cls_targets = [[0, 0, 0],
+ [0, 0, 0],
+ [0, 0, 0],
+ [0, 0, 0]]
+ exp_cls_weights = [[1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1]]
+ exp_reg_targets = [[0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]
+ exp_reg_weights = [0, 0, 0, 0]
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, groundtruth_labels])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+ self.assertEquals(cls_targets_out.dtype, np.float32)
+ self.assertEquals(cls_weights_out.dtype, np.float32)
+ self.assertEquals(reg_targets_out.dtype, np.float32)
+ self.assertEquals(reg_weights_out.dtype, np.float32)
+
+ def test_raises_error_on_incompatible_groundtruth_boxes_and_labels(self):
+ similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder()
+ unmatched_class_label = tf.constant([1, 0, 0, 0, 0, 0, 0], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ prior_means = tf.constant([[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 1.0, 0.8],
+ [0, 0.5, .5, 1.0],
+ [.75, 0, 1.0, .25]])
+ priors = box_list.BoxList(prior_means)
+
+ box_corners = [[0.0, 0.0, 0.5, 0.5],
+ [0.0, 0.0, 0.5, 0.8],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+
+ groundtruth_labels = tf.constant([[0, 1, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 1, 0],
+ [0, 0, 0, 1, 0, 0, 0]], tf.float32)
+ with self.assertRaisesRegexp(ValueError, 'Unequal shapes'):
+ target_assigner.assign(
+ priors,
+ boxes,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+
+ def test_raises_error_on_invalid_groundtruth_labels(self):
+ similarity_calc = region_similarity_calculator.NegSqDistSimilarity()
+ matcher = bipartite_matcher.GreedyBipartiteMatcher()
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=1.0)
+ unmatched_class_label = tf.constant([[0, 0], [0, 0], [0, 0]], tf.float32)
+ target_assigner = targetassigner.TargetAssigner(
+ similarity_calc, matcher, box_coder)
+
+ prior_means = tf.constant([[0.0, 0.0, 0.5, 0.5]])
+ priors = box_list.BoxList(prior_means)
+
+ box_corners = [[0.0, 0.0, 0.5, 0.5],
+ [0.5, 0.5, 0.9, 0.9],
+ [.75, 0, .95, .27]]
+ boxes = box_list.BoxList(tf.constant(box_corners))
+ groundtruth_labels = tf.constant([[[0, 1], [1, 0]]], tf.float32)
+
+ with self.assertRaises(ValueError):
+ target_assigner.assign(
+ priors,
+ boxes,
+ groundtruth_labels,
+ unmatched_class_label=unmatched_class_label)
+
+
+class BatchTargetAssignerTest(test_case.TestCase):
+
+ def _get_target_assigner(self):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ return targetassigner.TargetAssigner(similarity_calc, matcher, box_coder)
+
+ def test_batch_assign_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [None, None]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ agnostic_target_assigner = self._get_target_assigner()
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ agnostic_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[1], [0], [0], [0]],
+ [[0], [1], [1], [0]]]
+ exp_cls_weights = [[[1], [1], [1], [1]],
+ [[1], [1], [1], [1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_boxlist1, groundtruth_boxlist2])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multiclass_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]],
+ [[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multiclass_targets_with_padded_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ gt_weights = [groundtruth_weights1, groundtruth_weights2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label, gt_weights)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2],
+ [0., 0., 0., 0.]], dtype=np.float32)
+ groundtruth_weights1 = np.array([1, 0], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842],
+ [0, 0, 0, 0]],
+ dtype=np.float32)
+ groundtruth_weights2 = np.array([1, 1, 0], dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0], [0, 0, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [0, 0, 0, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, 1, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]],
+ [[1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_multidimensional_targets(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_targets = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ target_dimensions = (2, 3)
+ unmatched_class_label = tf.constant(np.zeros(target_dimensions),
+ tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist, gt_box_batch,
+ gt_class_targets, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[[0, 1, 1],
+ [1, 1, 0]]], dtype=np.float32)
+ class_targets2 = np.array([[[0, 1, 1],
+ [1, 1, 0]],
+ [[0, 0, 1],
+ [0, 0, 1]]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[[0., 1., 1.],
+ [1., 1., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]]],
+ [[[0., 0., 0.],
+ [0., 0., 0.]],
+ [[0., 1., 1.],
+ [1., 1., 0.]],
+ [[0., 0., 1.],
+ [0., 0., 1.]],
+ [[0., 0., 0.],
+ [0., 0., 0.]]]]
+ exp_cls_weights = [[[[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]]],
+ [[[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]],
+ [[1., 1., 1.],
+ [1., 1., 1.]]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, gt_class_targets):
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ gt_box_batch = [groundtruth_boxlist]
+ gt_class_targets_batch = [gt_class_targets]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_targets(
+ multiclass_target_assigner, anchors_boxlist,
+ gt_box_batch, gt_class_targets_batch, unmatched_class_label)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 1, 1],
+ [1, 1, 1, 1]]]
+ exp_reg_targets = [[[0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[0, 0]]
+ num_classes = 3
+ pad = 1
+ gt_class_targets = np.zeros((0, num_classes + pad), dtype=np.float32)
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_box_corners, gt_class_targets])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+
+class BatchGetTargetsTest(test_case.TestCase):
+
+ def test_scalar_targets(self):
+ batch_match = np.array([[1, 0, 1],
+ [-2, -1, 1]], dtype=np.int32)
+ groundtruth_tensors_list = np.array([[11, 12], [13, 14]], dtype=np.int32)
+ groundtruth_weights_list = np.array([[1.0, 1.0], [1.0, 0.5]],
+ dtype=np.float32)
+ unmatched_value = np.array(99, dtype=np.int32)
+ unmatched_weight = np.array(0.0, dtype=np.float32)
+
+ def graph_fn(batch_match, groundtruth_tensors_list,
+ groundtruth_weights_list, unmatched_value, unmatched_weight):
+ targets, weights = targetassigner.batch_get_targets(
+ batch_match, tf.unstack(groundtruth_tensors_list),
+ tf.unstack(groundtruth_weights_list),
+ unmatched_value, unmatched_weight)
+ return (targets, weights)
+
+ (targets_np, weights_np) = self.execute(graph_fn, [
+ batch_match, groundtruth_tensors_list, groundtruth_weights_list,
+ unmatched_value, unmatched_weight
+ ])
+ self.assertAllEqual([[12, 11, 12],
+ [99, 99, 14]], targets_np)
+ self.assertAllClose([[1.0, 1.0, 1.0],
+ [0.0, 0.0, 0.5]], weights_np)
+
+ def test_1d_targets(self):
+ batch_match = np.array([[1, 0, 1],
+ [-2, -1, 1]], dtype=np.int32)
+ groundtruth_tensors_list = np.array([[[11, 12], [12, 13]],
+ [[13, 14], [14, 15]]],
+ dtype=np.float32)
+ groundtruth_weights_list = np.array([[1.0, 1.0], [1.0, 0.5]],
+ dtype=np.float32)
+ unmatched_value = np.array([99, 99], dtype=np.float32)
+ unmatched_weight = np.array(0.0, dtype=np.float32)
+
+ def graph_fn(batch_match, groundtruth_tensors_list,
+ groundtruth_weights_list, unmatched_value, unmatched_weight):
+ targets, weights = targetassigner.batch_get_targets(
+ batch_match, tf.unstack(groundtruth_tensors_list),
+ tf.unstack(groundtruth_weights_list),
+ unmatched_value, unmatched_weight)
+ return (targets, weights)
+
+ (targets_np, weights_np) = self.execute(graph_fn, [
+ batch_match, groundtruth_tensors_list, groundtruth_weights_list,
+ unmatched_value, unmatched_weight
+ ])
+ self.assertAllClose([[[12, 13], [11, 12], [12, 13]],
+ [[99, 99], [99, 99], [14, 15]]], targets_np)
+ self.assertAllClose([[1.0, 1.0, 1.0],
+ [0.0, 0.0, 0.5]], weights_np)
+
+
+class BatchTargetAssignConfidencesTest(test_case.TestCase):
+
+ def _get_target_assigner(self):
+ similarity_calc = region_similarity_calculator.IouSimilarity()
+ matcher = argmax_matcher.ArgMaxMatcher(matched_threshold=0.5,
+ unmatched_threshold=0.5)
+ box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
+ return targetassigner.TargetAssigner(similarity_calc, matcher, box_coder)
+
+ def test_batch_assign_empty_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_box_corners, gt_class_confidences):
+ groundtruth_boxlist = box_list.BoxList(groundtruth_box_corners)
+ gt_box_batch = [groundtruth_boxlist]
+ gt_class_confidences_batch = [gt_class_confidences]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+
+ num_classes = 3
+ implicit_class_weight = 0.5
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ multiclass_target_assigner = self._get_target_assigner()
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_box_corners = np.zeros((0, 4), dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1]], dtype=np.float32)
+ num_classes = 3
+ pad = 1
+ gt_class_confidences = np.zeros((0, num_classes + pad), dtype=np.float32)
+
+ exp_cls_targets = [[[1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[0, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn,
+ [anchor_means, groundtruth_box_corners, gt_class_confidences])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_agnostic(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [None, None]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ agnostic_target_assigner = self._get_target_assigner()
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ agnostic_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ include_background_class=False,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[1], [0], [0], [0]],
+ [[0], [1], [1], [0]]]
+ exp_cls_weights = [[[1], [0.5], [0.5], [0.5]],
+ [[0.5], [1], [1], [0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0.15789001, -0.01500003, 0.57889998, -1.15799987],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 1, 0]]
+
+ (cls_targets_out,
+ cls_weights_out, reg_targets_out, reg_weights_out) = self.execute(
+ graph_fn, [anchor_means, groundtruth_boxlist1, groundtruth_boxlist2])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multiclass(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ implicit_class_weight = 0.5
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, -1, 0]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]],
+ [[0.5, 0.5, 0.5, 0.5],
+ [1, 0.5, 0.5, 1],
+ [0.5, 0.5, 1, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 0, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multiclass_with_padded_groundtruth(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ gt_weights = [groundtruth_weights1, groundtruth_weights2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ num_classes = 3
+ unmatched_class_label = tf.constant([1] + num_classes * [0], tf.float32)
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ gt_weights,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2],
+ [0., 0., 0., 0.]], dtype=np.float32)
+ groundtruth_weights1 = np.array([1, 0], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842],
+ [0, 0, 0, 0]],
+ dtype=np.float32)
+ groundtruth_weights2 = np.array([1, 1, 0], dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0], [0, 0, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, -1, 0],
+ [0, 0, 0, 0]], dtype=np.float32)
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ exp_cls_targets = [[[0, 1, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]],
+ [[1, 0, 0, 0],
+ [0, 0, 0, 1],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0]]]
+ exp_cls_weights = [[[1, 1, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5],
+ [0.5, 0.5, 0.5, 0.5]],
+ [[0.5, 0.5, 0.5, 0.5],
+ [1, 0.5, 0.5, 1],
+ [0.5, 0.5, 1, 0.5],
+ [0.5, 0.5, 0.5, 0.5]]]
+ exp_reg_targets = [[[0, 0, -0.5, -0.5],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0,],
+ [0, 0, 0, 0,],],
+ [[0, 0, 0, 0,],
+ [0, 0.01231521, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]]]
+ exp_reg_weights = [[1, 0, 0, 0],
+ [0, 1, 0, 0]]
+
+ (cls_targets_out, cls_weights_out, reg_targets_out,
+ reg_weights_out) = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2, groundtruth_weights1,
+ groundtruth_weights2
+ ])
+ self.assertAllClose(cls_targets_out, exp_cls_targets)
+ self.assertAllClose(cls_weights_out, exp_cls_weights)
+ self.assertAllClose(reg_targets_out, exp_reg_targets)
+ self.assertAllClose(reg_weights_out, exp_reg_weights)
+
+ def test_batch_assign_confidences_multidimensional(self):
+
+ def graph_fn(anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2):
+ box_list1 = box_list.BoxList(groundtruth_boxlist1)
+ box_list2 = box_list.BoxList(groundtruth_boxlist2)
+ gt_box_batch = [box_list1, box_list2]
+ gt_class_confidences_batch = [class_targets1, class_targets2]
+ anchors_boxlist = box_list.BoxList(anchor_means)
+ multiclass_target_assigner = self._get_target_assigner()
+ target_dimensions = (2, 3)
+ unmatched_class_label = tf.constant(np.zeros(target_dimensions),
+ tf.float32)
+ implicit_class_weight = 0.5
+ (cls_targets, cls_weights, reg_targets, reg_weights,
+ _) = targetassigner.batch_assign_confidences(
+ multiclass_target_assigner,
+ anchors_boxlist,
+ gt_box_batch,
+ gt_class_confidences_batch,
+ unmatched_class_label=unmatched_class_label,
+ include_background_class=True,
+ implicit_class_weight=implicit_class_weight)
+ return (cls_targets, cls_weights, reg_targets, reg_weights)
+
+ groundtruth_boxlist1 = np.array([[0., 0., 0.2, 0.2]], dtype=np.float32)
+ groundtruth_boxlist2 = np.array([[0, 0.25123152, 1, 1],
+ [0.015789, 0.0985, 0.55789, 0.3842]],
+ dtype=np.float32)
+ class_targets1 = np.array([[0, 1, 0, 0]], dtype=np.float32)
+ class_targets2 = np.array([[0, 0, 0, 1],
+ [0, 0, 1, 0]], dtype=np.float32)
+ class_targets1 = np.array([[[0, 1, 1],
+ [1, 1, 0]]], dtype=np.float32)
+ class_targets2 = np.array([[[0, 1, 1],
+ [1, 1, 0]],
+ [[0, 0, 1],
+ [0, 0, 1]]], dtype=np.float32)
+
+ anchor_means = np.array([[0, 0, .25, .25],
+ [0, .25, 1, 1],
+ [0, .1, .5, .5],
+ [.75, .75, 1, 1]], dtype=np.float32)
+
+ with self.assertRaises(ValueError):
+ _, _, _, _ = self.execute(graph_fn, [
+ anchor_means, groundtruth_boxlist1, groundtruth_boxlist2,
+ class_targets1, class_targets2
+ ])
+
+
+class CreateTargetAssignerTest(tf.test.TestCase):
+
+ def test_create_target_assigner(self):
+ """Tests that named constructor gives working target assigners.
+
+ TODO(rathodv): Make this test more general.
+ """
+ corners = [[0.0, 0.0, 1.0, 1.0]]
+ groundtruth = box_list.BoxList(tf.constant(corners))
+
+ priors = box_list.BoxList(tf.constant(corners))
+ multibox_ta = (targetassigner
+ .create_target_assigner('Multibox', stage='proposal'))
+ multibox_ta.assign(priors, groundtruth)
+ # No tests on output, as that may vary arbitrarily as new target assigners
+ # are added. As long as it is constructed correctly and runs without errors,
+ # tests on the individual assigners cover correctness of the assignments.
+
+ anchors = box_list.BoxList(tf.constant(corners))
+ faster_rcnn_proposals_ta = (targetassigner
+ .create_target_assigner('FasterRCNN',
+ stage='proposal'))
+ faster_rcnn_proposals_ta.assign(anchors, groundtruth)
+
+ fast_rcnn_ta = (targetassigner
+ .create_target_assigner('FastRCNN'))
+ fast_rcnn_ta.assign(anchors, groundtruth)
+
+ faster_rcnn_detection_ta = (targetassigner
+ .create_target_assigner('FasterRCNN',
+ stage='detection'))
+ faster_rcnn_detection_ta.assign(anchors, groundtruth)
+
+ with self.assertRaises(ValueError):
+ targetassigner.create_target_assigner('InvalidDetector',
+ stage='invalid_stage')
+
+
+if __name__ == '__main__':
+ tf.test.main()
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/images/out.jpg b/Computer Vision/Plant_Disease_Detection_System/object_detection/images/out.jpg
new file mode 100644
index 00000000..c8b1f38b
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/images/out.jpg differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/checkpoint b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/checkpoint
new file mode 100644
index 00000000..febd7d54
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/checkpoint
@@ -0,0 +1,2 @@
+model_checkpoint_path: "model.ckpt"
+all_model_checkpoint_paths: "model.ckpt"
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/frozen_inference_graph.pb b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/frozen_inference_graph.pb
new file mode 100644
index 00000000..4c721a6b
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/frozen_inference_graph.pb differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/pipeline.config b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/pipeline.config
new file mode 100644
index 00000000..c949caca
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/pipeline.config
@@ -0,0 +1,134 @@
+model {
+ faster_rcnn {
+ num_classes: 6
+ image_resizer {
+ keep_aspect_ratio_resizer {
+ min_dimension: 600
+ max_dimension: 1024
+ }
+ }
+ feature_extractor {
+ type: "faster_rcnn_inception_v2"
+ first_stage_features_stride: 16
+ }
+ first_stage_anchor_generator {
+ grid_anchor_generator {
+ height_stride: 16
+ width_stride: 16
+ scales: 0.25
+ scales: 0.5
+ scales: 1.0
+ scales: 2.0
+ aspect_ratios: 0.5
+ aspect_ratios: 1.0
+ aspect_ratios: 2.0
+ }
+ }
+ first_stage_box_predictor_conv_hyperparams {
+ op: CONV
+ regularizer {
+ l2_regularizer {
+ weight: 0.0
+ }
+ }
+ initializer {
+ truncated_normal_initializer {
+ stddev: 0.0099999998
+ }
+ }
+ }
+ first_stage_nms_score_threshold: 0.0
+ first_stage_nms_iou_threshold: 0.69999999
+ first_stage_max_proposals: 300
+ first_stage_localization_loss_weight: 2.0
+ first_stage_objectness_loss_weight: 1.0
+ initial_crop_size: 14
+ maxpool_kernel_size: 2
+ maxpool_stride: 2
+ second_stage_box_predictor {
+ mask_rcnn_box_predictor {
+ fc_hyperparams {
+ op: FC
+ regularizer {
+ l2_regularizer {
+ weight: 0.0
+ }
+ }
+ initializer {
+ variance_scaling_initializer {
+ factor: 1.0
+ uniform: true
+ mode: FAN_AVG
+ }
+ }
+ }
+ use_dropout: false
+ dropout_keep_probability: 1.0
+ }
+ }
+ second_stage_post_processing {
+ batch_non_max_suppression {
+ score_threshold: 0.0
+ iou_threshold: 0.60000002
+ max_detections_per_class: 100
+ max_total_detections: 300
+ }
+ score_converter: SOFTMAX
+ }
+ second_stage_localization_loss_weight: 2.0
+ second_stage_classification_loss_weight: 1.0
+ }
+}
+train_config {
+ batch_size: 1
+ data_augmentation_options {
+ random_horizontal_flip {
+ }
+ }
+ optimizer {
+ momentum_optimizer {
+ learning_rate {
+ manual_step_learning_rate {
+ initial_learning_rate: 0.00019999999
+ schedule {
+ step: 1
+ learning_rate: 0.00019999999
+ }
+ schedule {
+ step: 900000
+ learning_rate: 1.9999999e-05
+ }
+ schedule {
+ step: 1200000
+ learning_rate: 2e-06
+ }
+ }
+ }
+ momentum_optimizer_value: 0.89999998
+ }
+ use_moving_average: false
+ }
+ gradient_clipping_by_norm: 10.0
+ fine_tune_checkpoint: "C:/tensorflow1/models/research/object_detection/faster_rcnn_inception_v2_coco_2018_01_28/model.ckpt"
+ from_detection_checkpoint: true
+ num_steps: 200000
+}
+train_input_reader {
+ label_map_path: "C:/tensorflow1/models/research/object_detection/training/labelmap.pbtxt"
+ tf_record_input_reader {
+ input_path: "C:/tensorflow1/models/research/object_detection/train.record"
+ }
+}
+eval_config {
+ num_examples: 67
+ max_evals: 10
+ use_moving_averages: false
+}
+eval_input_reader {
+ label_map_path: "C:/tensorflow1/models/research/object_detection/training/labelmap.pbtxt"
+ shuffle: false
+ num_readers: 1
+ tf_record_input_reader {
+ input_path: "C:/tensorflow1/models/research/object_detection/test.record"
+ }
+}
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/saved_model/saved_model.pb b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/saved_model/saved_model.pb
new file mode 100644
index 00000000..e52a00ea
Binary files /dev/null and b/Computer Vision/Plant_Disease_Detection_System/object_detection/inference_graph/saved_model/saved_model.pb differ
diff --git a/Computer Vision/Plant_Disease_Detection_System/object_detection/training/graph.pbtxt b/Computer Vision/Plant_Disease_Detection_System/object_detection/training/graph.pbtxt
new file mode 100644
index 00000000..813e0712
--- /dev/null
+++ b/Computer Vision/Plant_Disease_Detection_System/object_detection/training/graph.pbtxt
@@ -0,0 +1,572021 @@
+node {
+ name: "global_step/Initializer/zeros"
+ op: "Const"
+ attr {
+ key: "_class"
+ value {
+ list {
+ s: "loc:@global_step"
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 0
+ }
+ }
+ }
+}
+node {
+ name: "global_step"
+ op: "VariableV2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_class"
+ value {
+ list {
+ s: "loc:@global_step"
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "container"
+ value {
+ s: ""
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "shape"
+ value {
+ shape {
+ }
+ }
+ }
+ attr {
+ key: "shared_name"
+ value {
+ s: ""
+ }
+ }
+}
+node {
+ name: "global_step/Assign"
+ op: "Assign"
+ input: "global_step"
+ input: "global_step/Initializer/zeros"
+ device: "/device:CPU:0"
+ attr {
+ key: "T"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "_class"
+ value {
+ list {
+ s: "loc:@global_step"
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "use_locking"
+ value {
+ b: true
+ }
+ }
+ attr {
+ key: "validate_shape"
+ value {
+ b: true
+ }
+ }
+}
+node {
+ name: "global_step/read"
+ op: "Identity"
+ input: "global_step"
+ device: "/device:CPU:0"
+ attr {
+ key: "T"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "_class"
+ value {
+ list {
+ s: "loc:@global_step"
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+}
+node {
+ name: "Const"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 6
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_STRING
+ tensor_shape {
+ dim {
+ size: 6
+ }
+ }
+ string_val: "Grape_Black_rot"
+ string_val: "Grape___healthy"
+ string_val: "Cherry_Powdery_mildew"
+ string_val: "Cherry_Healthy"
+ string_val: "Grape___Leaf_blight_(Isariopsis_Leaf_Spot)"
+ string_val: "Grape___Esca_(Black_Measles)"
+ }
+ }
+ }
+}
+node {
+ name: "Const_1"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 6
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ dim {
+ size: 6
+ }
+ }
+ tensor_content: "\006\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\005\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000"
+ }
+ }
+ }
+}
+node {
+ name: "Const_2"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: -1
+ }
+ }
+ }
+}
+node {
+ name: "hash_table"
+ op: "HashTableV2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "container"
+ value {
+ s: ""
+ }
+ }
+ attr {
+ key: "key_dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "shared_name"
+ value {
+ s: "hash_table_e8ab7e44-951a-4911-94ee-f4bc682dd2c3"
+ }
+ }
+ attr {
+ key: "use_node_name_sharing"
+ value {
+ b: false
+ }
+ }
+ attr {
+ key: "value_dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "key_value_init/LookupTableImportV2"
+ op: "LookupTableImportV2"
+ input: "hash_table"
+ input: "Const"
+ input: "Const_1"
+ device: "/device:CPU:0"
+ attr {
+ key: "Tin"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "Tout"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "Const_3"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 1
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_STRING
+ tensor_shape {
+ dim {
+ size: 1
+ }
+ }
+ string_val: ""
+ }
+ }
+ }
+}
+node {
+ name: "Const_4"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 1
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ dim {
+ size: 1
+ }
+ }
+ int64_val: 6
+ }
+ }
+ }
+}
+node {
+ name: "Const_5"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: -1
+ }
+ }
+ }
+}
+node {
+ name: "hash_table_1"
+ op: "HashTableV2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "container"
+ value {
+ s: ""
+ }
+ }
+ attr {
+ key: "key_dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "shared_name"
+ value {
+ s: "hash_table_f3884bda-7cc0-41a3-9571-380825c15784"
+ }
+ }
+ attr {
+ key: "use_node_name_sharing"
+ value {
+ b: false
+ }
+ }
+ attr {
+ key: "value_dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "key_value_init_1/LookupTableImportV2"
+ op: "LookupTableImportV2"
+ input: "hash_table_1"
+ input: "Const_3"
+ input: "Const_4"
+ device: "/device:CPU:0"
+ attr {
+ key: "Tin"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "Tout"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "Const_6"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 6
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_STRING
+ tensor_shape {
+ dim {
+ size: 6
+ }
+ }
+ string_val: "Grape_Black_rot"
+ string_val: "Grape___healthy"
+ string_val: "Cherry_Powdery_mildew"
+ string_val: "Cherry_Healthy"
+ string_val: "Grape___Leaf_blight_(Isariopsis_Leaf_Spot)"
+ string_val: "Grape___Esca_(Black_Measles)"
+ }
+ }
+ }
+}
+node {
+ name: "Const_7"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 6
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ dim {
+ size: 6
+ }
+ }
+ tensor_content: "\006\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\005\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000"
+ }
+ }
+ }
+}
+node {
+ name: "Const_8"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: -1
+ }
+ }
+ }
+}
+node {
+ name: "hash_table_2"
+ op: "HashTableV2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "container"
+ value {
+ s: ""
+ }
+ }
+ attr {
+ key: "key_dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "shared_name"
+ value {
+ s: "hash_table_826efc29-125b-49cb-83c6-f8cdf0b0b3b3"
+ }
+ }
+ attr {
+ key: "use_node_name_sharing"
+ value {
+ b: false
+ }
+ }
+ attr {
+ key: "value_dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "key_value_init_2/LookupTableImportV2"
+ op: "LookupTableImportV2"
+ input: "hash_table_2"
+ input: "Const_6"
+ input: "Const_7"
+ device: "/device:CPU:0"
+ attr {
+ key: "Tin"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "Tout"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "Const_9"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 1
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_STRING
+ tensor_shape {
+ dim {
+ size: 1
+ }
+ }
+ string_val: ""
+ }
+ }
+ }
+}
+node {
+ name: "Const_10"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 1
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ dim {
+ size: 1
+ }
+ }
+ int64_val: 6
+ }
+ }
+ }
+}
+node {
+ name: "Const_11"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: -1
+ }
+ }
+ }
+}
+node {
+ name: "hash_table_3"
+ op: "HashTableV2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "container"
+ value {
+ s: ""
+ }
+ }
+ attr {
+ key: "key_dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "shared_name"
+ value {
+ s: "hash_table_16e513c0-5df2-4458-af96-02bb455ce8f5"
+ }
+ }
+ attr {
+ key: "use_node_name_sharing"
+ value {
+ b: false
+ }
+ }
+ attr {
+ key: "value_dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "key_value_init_3/LookupTableImportV2"
+ op: "LookupTableImportV2"
+ input: "hash_table_3"
+ input: "Const_9"
+ input: "Const_10"
+ device: "/device:CPU:0"
+ attr {
+ key: "Tin"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "Tout"
+ value {
+ type: DT_INT64
+ }
+ }
+}
+node {
+ name: "normalize_element/component_0"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ dim {
+ size: 1
+ }
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_STRING
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_STRING
+ tensor_shape {
+ dim {
+ size: 1
+ }
+ }
+ string_val: "C:\\tensorflow1\\models\\research\\object_detection\\train.record"
+ }
+ }
+ }
+}
+node {
+ name: "TensorSliceDataset"
+ op: "TensorSliceDataset"
+ input: "normalize_element/component_0"
+ device: "/device:CPU:0"
+ attr {
+ key: "Toutput_types"
+ value {
+ list {
+ type: DT_STRING
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+}
+node {
+ name: "buffer_size"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 100
+ }
+ }
+ }
+}
+node {
+ name: "seed"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 0
+ }
+ }
+ }
+}
+node {
+ name: "seed2"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 0
+ }
+ }
+ }
+}
+node {
+ name: "ShuffleDataset"
+ op: "ShuffleDataset"
+ input: "TensorSliceDataset"
+ input: "buffer_size"
+ input: "seed"
+ input: "seed2"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "output_types"
+ value {
+ list {
+ type: DT_STRING
+ }
+ }
+ }
+ attr {
+ key: "reshuffle_each_iteration"
+ value {
+ b: true
+ }
+ }
+}
+node {
+ name: "count"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: -1
+ }
+ }
+ }
+}
+node {
+ name: "RepeatDataset"
+ op: "RepeatDataset"
+ input: "ShuffleDataset"
+ input: "count"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "output_types"
+ value {
+ list {
+ type: DT_STRING
+ }
+ }
+ }
+}
+node {
+ name: "cycle_length"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 1
+ }
+ }
+ }
+}
+node {
+ name: "block_length"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 32
+ }
+ }
+ }
+}
+node {
+ name: "sloppy"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_BOOL
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_BOOL
+ tensor_shape {
+ }
+ bool_val: true
+ }
+ }
+ }
+}
+node {
+ name: "buffer_output_elements"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 64
+ }
+ }
+ }
+}
+node {
+ name: "prefetch_input_elements"
+ op: "Const"
+ device: "/device:CPU:0"
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "dtype"
+ value {
+ type: DT_INT64
+ }
+ }
+ attr {
+ key: "value"
+ value {
+ tensor {
+ dtype: DT_INT64
+ tensor_shape {
+ }
+ int64_val: 2
+ }
+ }
+ }
+}
+node {
+ name: "ParallelInterleaveDataset"
+ op: "ParallelInterleaveDataset"
+ input: "RepeatDataset"
+ input: "cycle_length"
+ input: "block_length"
+ input: "sloppy"
+ input: "buffer_output_elements"
+ input: "prefetch_input_elements"
+ device: "/device:CPU:0"
+ attr {
+ key: "Targuments"
+ value {
+ list {
+ }
+ }
+ }
+ attr {
+ key: "_output_shapes"
+ value {
+ list {
+ shape {
+ }
+ }
+ }
+ }
+ attr {
+ key: "f"
+ value {
+ func {
+ name: "__inference_tf_data_experimental_parallel_interleave_